source: src/main/java/weka/gui/visualize/AttributePanel.java @ 17

/*
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 *    AttributePanel.java
 *    Copyright (C) 1999 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.gui.visualize;

import weka.core.Attribute;
import weka.core.FastVector;
import weka.core.Instances;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JPanel;
import javax.swing.JScrollPane;

/**
 * This panel displays one dimensional views of the attributes in a
 * dataset. Colouring is done on the basis of a column in the dataset or
 * an auxiliary array (useful for colouring cluster predictions).
 * 
 * @author Malcolm Ware (mfw4@cs.waikato.ac.nz)
 * @author Mark Hall (mhall@cs.waikato.ac.nz)
 * @version $Revision: 5086 $
 */
public class AttributePanel
  extends JScrollPane {

  /** for serialization */
  private static final long serialVersionUID = 3533330317806757814L;
  
  /** The instances to be plotted */
  protected Instances m_plotInstances=null;
    
  /** Holds the min and max values of the colouring attributes */
  protected double m_maxC;
  protected double m_minC;
  protected int m_cIndex;
  protected int m_xIndex;
  protected int m_yIndex;

  /** The colour map to use for colouring points */
  protected FastVector m_colorList;

   /** default colours for colouring discrete class */
    protected Color [] m_DefaultColors = {Color.blue,
                                        Color.red,
                                        Color.green,
                                        Color.cyan,
                                        Color.pink,
                                        new Color(255, 0, 255),
                                        Color.orange,
                                        new Color(255, 0, 0),
                                        new Color(0, 255, 0),
                                        Color.white};
    
  /**
   *  If set, it allows this panel to avoid setting a color in
   * the color list that is equal to the background color
   */
  protected Color m_backgroundColor = null; 

  /** The list of things listening to this panel */
  protected FastVector m_Listeners = new FastVector();

  /** Holds the random height for each instance. */
  protected int[] m_heights;
  //protected Color[] colors_array;

  /** The container window for the attribute bars, and also where the
   * X,Y or B get printed.
   */ 
  protected JPanel m_span=null;

  /** The default colour to use for the background of the bars if
      a colour is not defined in Visualize.props */
  protected Color m_barColour=Color.black;
    
  /** inner inner class used for plotting the points 
   * into a bar for a particular attribute. 
   */
  protected class AttributeSpacing
    extends JPanel {

    /** for serialization */
    private static final long serialVersionUID = 7220615894321679898L;

    /** The min and max values for this attribute. */
    protected double m_maxVal;
    protected double m_minVal;

    /** The attribute itself. */
    protected Attribute m_attrib;
      
    /** The index for this attribute. */
    protected int m_attribIndex;
      
    /** The x position of each point. */
    protected int[] m_cached;
    //note for m_cached, if you wanted to speed up the drawing algorithm
    // and save memory, the system could be setup to drop out any
    // of the instances not being drawn (you would need to find a new way
    //of matching the height however).

    /** A temporary array used to strike any instances that would be 
     * drawn redundantly.
     */
    protected boolean[][] m_pointDrawn;
      
    /** Used to determine if the positions need to be recalculated. */
    protected int m_oldWidth=-9000;

    /** The container window for the attribute bars, and also where the
     * X,Y or B get printed.
     */
      
    /**
     * This constructs the bar with the specified attribute and
     * sets its index to be used for selecting by the mouse.
     * @param a The attribute this bar represents.
     * @param aind The index of this bar.
     */
    public AttributeSpacing(Attribute a, int aind) {
      m_attrib = a;
      m_attribIndex = aind;
      this.setBackground(m_barColour);
      this.setPreferredSize(new Dimension(0, 20));
      this.setMinimumSize(new Dimension(0, 20));
      m_cached = new int[m_plotInstances.numInstances()];
        
      //this will only get allocated if m_plotInstances != null
      //this is used to determine the min and max values for plotting
      double min=Double.POSITIVE_INFINITY;
      double max=Double.NEGATIVE_INFINITY;
      double value;
      if (m_plotInstances.attribute(m_attribIndex).isNominal()) {
        m_minVal = 0;
        m_maxVal = m_plotInstances.attribute(m_attribIndex).numValues()-1;
      } else {
        for (int i=0;i<m_plotInstances.numInstances();i++) {
          if (!m_plotInstances.instance(i).isMissing(m_attribIndex)) {
            value = m_plotInstances.instance(i).value(m_attribIndex);
            if (value < min) {
              min = value;
            }
            if (value > max) {
              max = value;
            }
          }
        }
        m_minVal = min; m_maxVal = max;
        if (min == max) {
          m_maxVal += 0.05;
          m_minVal -= 0.05;
        }
      }
        
      this.addMouseListener(new MouseAdapter() {
          public void mouseClicked(MouseEvent e) {
            if ((e.getModifiers() & e.BUTTON1_MASK) == e.BUTTON1_MASK) {
              setX(m_attribIndex);
              if (m_Listeners.size() > 0) {
                for (int i=0;i<m_Listeners.size();i++) {
                  AttributePanelListener l = 
                    (AttributePanelListener)(m_Listeners.elementAt(i));
                  l.attributeSelectionChange(new AttributePanelEvent(true,
                                             false, m_attribIndex));
                }
              }
            }
            else {
              //put it on the y axis
              setY(m_attribIndex);
              if (m_Listeners.size() > 0) {
                for (int i=0;i<m_Listeners.size();i++) {
                  AttributePanelListener l = 
                    (AttributePanelListener)(m_Listeners.elementAt(i));
                  l.attributeSelectionChange(new AttributePanelEvent(false,
                                             true, m_attribIndex));
                }
              }
            }
          }
        });
    }
      
    /**
     * Convert an raw x value to Panel x coordinate.
     * @param val the raw x value
     * @return an x value for plotting in the panel.
     */
    private double convertToPanel(double val) {
      double temp = (val - m_minVal)/(m_maxVal - m_minVal);
      double temp2 = temp * (this.getWidth() - 10);
        
      return temp2 + 4; 
    }
      
    /**
     * paints all the visible instances to the panel , and recalculates
     * their position if need be.
     * @param gx The graphics context.
     */
    public void paintComponent(Graphics gx) {
      super.paintComponent(gx);
      int xp, yp, h;
      h = this.getWidth();
      if (m_plotInstances != null 
          && m_plotInstances.numAttributes() > 0
          && m_plotInstances.numInstances() > 0) {

        if (m_oldWidth != h) {
          m_pointDrawn = new boolean[h][20];
          for (int noa = 0; noa < m_plotInstances.numInstances(); noa++) {
            if (!m_plotInstances.instance(noa).isMissing(m_attribIndex)
                && !m_plotInstances.instance(noa).isMissing(m_cIndex)) {
              m_cached[noa] = (int)convertToPanel(m_plotInstances.
                                                  instance(noa).
                                                  value(m_attribIndex));
                
              if (m_pointDrawn[m_cached[noa] % h][m_heights[noa]]) {
                m_cached[noa] = -9000;
              }
              else {
                m_pointDrawn[m_cached[noa]%h][m_heights[noa]] = true;
              }
                
            }
            else {
              m_cached[noa] = -9000; //this value will not happen 
              //so it is safe
            }
          }
          m_oldWidth = h;
        }
          
        if (m_plotInstances.attribute(m_cIndex).isNominal()) {
          for (int noa = 0; noa < m_plotInstances.numInstances(); noa++) {
              
            if (m_cached[noa] != -9000) {
              xp = m_cached[noa];
              yp = m_heights[noa];
              if (m_plotInstances.attribute(m_attribIndex).
                  isNominal()) {
                xp += (int)(Math.random() * 5) - 2;
              }
              int ci = (int)m_plotInstances.instance(noa).value(m_cIndex);

              gx.setColor((Color)m_colorList.elementAt
                          (ci % m_colorList.size()));
              gx.drawRect(xp, yp, 1, 1);
            }
          }
        }
        else {
          double r;
          for (int noa = 0; noa < m_plotInstances.numInstances(); noa++) {
            if (m_cached[noa] != -9000) {                 
                
              r = (m_plotInstances.instance(noa).value(m_cIndex) 
                   - m_minC) / (m_maxC - m_minC);

              r = (r * 240) + 15;

              gx.setColor(new Color((int)r,150,(int)(255-r)));
                
              xp = m_cached[noa];
              yp = m_heights[noa];
              if (m_plotInstances.attribute(m_attribIndex).
                  isNominal()) {
                xp += (int)(Math.random() * 5) - 2;
              }
              gx.drawRect(xp, yp, 1, 1);
            }
          }
        }
      } 
    }
  }   
    
  /**
   * Set the properties for the AttributePanel
   */
  private void setProperties() {
    if (VisualizeUtils.VISUALIZE_PROPERTIES != null) {
      String thisClass = this.getClass().getName();
      String barKey = thisClass+".barColour";
      
      String barC = VisualizeUtils.VISUALIZE_PROPERTIES.
              getProperty(barKey);
      if (barC == null) {
        /*
        System.err.println("Warning: no configuration property found in "
                           +VisualizeUtils.PROPERTY_FILE
                           +" for "+barKey);
        */
      } else {
        //System.err.println("Setting attribute bar colour to: "+barC);
        m_barColour = VisualizeUtils.processColour(barC, m_barColour);
      }
    }
  }
  
  public AttributePanel() {
    this(null);
  }
 
  /**
   * This constructs an attributePanel.
   */
  public AttributePanel(Color background) {
    m_backgroundColor = background;
    
    setProperties();
    this.setBackground(Color.blue);
    setVerticalScrollBarPolicy(VERTICAL_SCROLLBAR_ALWAYS);
    m_colorList = new FastVector(10);

    for (int noa = m_colorList.size(); noa < 10; noa++) {
      Color pc = m_DefaultColors[noa % 10];
      int ija =  noa / 10;
      ija *= 2; 
      for (int j=0;j<ija;j++) {
        pc = pc.darker();
      }
      
      m_colorList.addElement(pc);
    }
  }

  /**
   * Add a listener to the list of things listening to this panel
   * @param a the listener to notify when attribute bars are clicked on
   */
  public void addAttributePanelListener(AttributePanelListener a) {
    m_Listeners.addElement(a);
  }
  
  /**
   * Set the index of the attribute by which to colour the data. Updates
   * the number of entries in the colour list if there are more values
   * for this new attribute than previous ones.
   * @param c the index of the attribute to colour on
   * @param h maximum value of this attribute
   * @param l minimum value of this attribute
   */
  public void setCindex(int c, double h, double l) {
    m_cIndex = c;
    m_maxC = h;
    m_minC = l;
    
    if (m_span != null) {
      if (m_plotInstances.numAttributes() > 0 &&
          m_cIndex < m_plotInstances.numAttributes()) {
        if (m_plotInstances.attribute(m_cIndex).isNominal()) {
          if (m_plotInstances.attribute(m_cIndex).numValues() > 
            m_colorList.size()) {
            extendColourMap();
          }
        }
      }
      this.repaint();
    }
  }

  /**
   * Set the index of the attribute by which to colour the data. Updates
   * the number of entries in the colour list if there are more values
   * for this new attribute than previous ones.
   * @param c the index of the attribute to colour on
   */
  public void setCindex(int c) {
    m_cIndex = c;
    /*    m_maxC = h;
          m_minC = l; */

    if (m_span != null) {
      if (m_cIndex < m_plotInstances.numAttributes() && 
          m_plotInstances.attribute(m_cIndex).isNumeric()) {
        double min=Double.POSITIVE_INFINITY;
        double max=Double.NEGATIVE_INFINITY;
        double value;

        for (int i=0;i<m_plotInstances.numInstances();i++) {
          if (!m_plotInstances.instance(i).isMissing(m_cIndex)) {
            value = m_plotInstances.instance(i).value(m_cIndex);
            if (value < min) {
              min = value;
            }
            if (value > max) {
              max = value;
            }
          }
        }
    
        m_minC = min; m_maxC = max;
      } else {
        if (m_plotInstances.attribute(m_cIndex).numValues() > 
            m_colorList.size()) {
          extendColourMap();
        }
      }
    
      this.repaint();
    }
  }

  /**
   * Adds more colours to the colour list
   */
  private void extendColourMap() {
    if (m_plotInstances.attribute(m_cIndex).isNominal()) {
      for (int i = m_colorList.size(); 
           i < m_plotInstances.attribute(m_cIndex).numValues();
           i++) {
        Color pc = m_DefaultColors[i % 10];
        int ija =  i / 10;
        ija *= 2; 
        for (int j=0;j<ija;j++) {
          pc = pc.brighter();
        }
        
        if (m_backgroundColor != null) {
          pc = Plot2D.checkAgainstBackground(pc, m_backgroundColor);
        }

        m_colorList.addElement(pc);
      }
    }
  }

  /**
   * Sets a list of colours to use for colouring data points
   * @param cols a list of java.awt.Color
   */
  public void setColours(FastVector cols) {
    m_colorList = cols;
  }
  
  protected void setDefaultColourList(Color[] list) {
    m_DefaultColors = list;
  }

  /** 
   * This sets the instances to be drawn into the attribute panel
   * @param ins The instances.
   */
  public void setInstances(Instances ins) throws Exception {
    if (ins.numAttributes() > 512) {
      throw new Exception("Can't display more than 512 attributes!");
    }

    if (m_span == null) {
      m_span = new JPanel() {
          private static final long serialVersionUID = 7107576557995451922L;
          
          public void paintComponent(Graphics gx) {
            super.paintComponent(gx);
            gx.setColor(Color.red);
            if (m_yIndex != m_xIndex) {
              gx.drawString("X", 5, m_xIndex * 20 + 16);
              gx.drawString("Y", 5, m_yIndex * 20 + 16);
            }
            else {
              gx.drawString("B", 5, m_xIndex * 20 + 16);
            }
          }
        };
    }

    m_span.removeAll();
    m_plotInstances = ins;
    if (ins.numInstances() > 0 && ins.numAttributes() > 0) {
      JPanel padder = new JPanel();
      JPanel padd2 = new JPanel();
      
      /*    if (m_splitListener != null) {
            m_plotInstances.randomize(new Random());
            } */

      m_heights = new int[ins.numInstances()];

      m_cIndex = ins.numAttributes() - 1;
      for (int noa = 0; noa < ins.numInstances(); noa++) {
        m_heights[noa] = (int)(Math.random() * 19);
      }
      m_span.setPreferredSize(new Dimension(m_span.getPreferredSize().width, 
                                            (m_cIndex + 1) * 20));
      m_span.setMaximumSize(new Dimension(m_span.getMaximumSize().width, 
                                          (m_cIndex + 1) * 20));
      AttributeSpacing tmp;
      
      GridBagLayout gb = new GridBagLayout();
      GridBagLayout gb2 = new GridBagLayout();
      GridBagConstraints constraints = new GridBagConstraints();
      


      padder.setLayout(gb);
      m_span.setLayout(gb2);
      constraints.anchor = GridBagConstraints.CENTER;
      constraints.gridx=0;constraints.gridy=0;constraints.weightx=5;
      constraints.fill = GridBagConstraints.HORIZONTAL;
      constraints.gridwidth=1;constraints.gridheight=1;
      constraints.insets = new Insets(0, 0, 0, 0);
      padder.add(m_span, constraints);
      constraints.gridx=0;constraints.gridy=1;constraints.weightx=5;
      constraints.fill = GridBagConstraints.BOTH;
      constraints.gridwidth=1;constraints.gridheight=1;constraints.weighty=5;
      constraints.insets = new Insets(0, 0, 0, 0);
      padder.add(padd2, constraints);
      constraints.weighty=0;
      setViewportView(padder);
      //getViewport().setLayout(null);
      //m_span.setMinimumSize(new Dimension(100, (m_cIndex + 1) * 24));
      //m_span.setSize(100, (m_cIndex + 1) * 24);
      constraints.anchor = GridBagConstraints.CENTER;
      constraints.gridx=0;constraints.gridy=0;constraints.weightx=5;
      constraints.fill = GridBagConstraints.HORIZONTAL;
      constraints.gridwidth=1;constraints.gridheight=1;constraints.weighty=5;
      constraints.insets = new Insets(2,20,2,4);

      for (int noa = 0; noa < ins.numAttributes(); noa++) {
        tmp = new AttributeSpacing(ins.attribute(noa), noa);
         
        constraints.gridy = noa;
        m_span.add(tmp, constraints);
      }
    }
  }
    
  /**
   * shows which bar is the current x attribute.
   * @param x The attributes index.
   */
  public void setX(int x) {
    if (m_span != null) {
      m_xIndex = x;
      m_span.repaint();
    }
  }
    
  /**
   * shows which bar is the current y attribute.
   * @param y The attributes index.
   */
  public void setY(int y) {
    if (m_span != null) {
      m_yIndex = y;
      m_span.repaint();
    }
  }

  /**
   * Main method for testing this class.
   * @param args first argument should be an arff file. Second argument
   * can be an optional class col
   */
  public static void main(String [] args) {
    try {
      if (args.length < 1) {
        System.err.println("Usage : weka.gui.visualize.AttributePanel "
                           +"<dataset> [class col]");
        System.exit(1);
      }
      final javax.swing.JFrame jf = 
        new javax.swing.JFrame("Weka Explorer: Attribute");
      jf.setSize(100,100);
      jf.getContentPane().setLayout(new BorderLayout());
      final AttributePanel p2 = new AttributePanel();
      p2.addAttributePanelListener(new AttributePanelListener() {
          public void attributeSelectionChange(AttributePanelEvent e) {
            if (e.m_xChange) {
              System.err.println("X index changed to : "+e.m_indexVal);
            } else {
              System.err.println("Y index changed to : "+e.m_indexVal);
            }
          }
        });
      jf.getContentPane().add(p2, BorderLayout.CENTER);
      jf.addWindowListener(new java.awt.event.WindowAdapter() {
          public void windowClosing(java.awt.event.WindowEvent e) {
            jf.dispose();
            System.exit(0);
          }
        });
      if (args.length >= 1) {
        System.err.println("Loading instances from " + args[0]);
        java.io.Reader r = new java.io.BufferedReader(
                           new java.io.FileReader(args[0]));
        Instances i = new Instances(r);
        i.setClassIndex(i.numAttributes()-1);
        p2.setInstances(i);
      }
      if (args.length > 1) {
        p2.setCindex((Integer.parseInt(args[1]))-1);
      } else {
        p2.setCindex(0);
      }
      jf.setVisible(true);
    } catch (Exception ex) {
       ex.printStackTrace();
       System.err.println(ex.getMessage());
     }
  }
}