/*
* 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.
*/
/*
* ClassPanel.java
* Copyright (C) 2000 University of Waikato, Hamilton, New Zealand
*
*/
package weka.gui.visualize;
import weka.core.FastVector;
import weka.core.Instances;
import weka.core.Utils;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JColorChooser;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* This panel displays coloured labels for nominal attributes and a spectrum
* for numeric attributes. It can also be told to colour on the basis
* of an array of doubles (this can be useful for displaying coloured labels
* that correspond to a clusterers predictions).
*
* @author Mark Hall (mhall@cs.waikato.ac.nz)
* @author Malcolm Ware (mfw4@cs.waikato.ac.nz)
* @version $Revision: 5086 $
*/
public class ClassPanel
extends JPanel {
/** for serialization */
private static final long serialVersionUID = -7969401840501661430L;
/** True when the panel has been enabled (ie after
setNumeric or setNominal has been called */
private boolean m_isEnabled = false;
/** True if the colouring attribute is numeric */
private boolean m_isNumeric = false;
/** The height of the spectrum for numeric class */
private final int m_spectrumHeight = 5;
/** The maximum value for the colouring attribute */
private double m_maxC;
/** The minimum value for the colouring attribute */
private double m_minC;
/** The size of the ticks */
private final int m_tickSize = 5;
/** Font metrics */
private FontMetrics m_labelMetrics = null;
/** The font used in labeling */
private Font m_labelFont = null;
/** The amount of space to leave either side of the legend */
private int m_HorizontalPad=0;
/** The precision with which to display real values */
private int m_precisionC;
/** Field width for numeric values */
private int m_fieldWidthC;
/** The old width. */
private int m_oldWidth = -9000;
/** Instances being plotted */
private Instances m_Instances=null;
/** Index of the colouring attribute */
private int m_cIndex;
/** the list of colours to use for colouring nominal attribute labels */
private FastVector m_colorList;
/** An optional list of Components that use the colour list
maintained by this class. If the user changes a colour
using the colour chooser, then these components need to
be repainted in order to display the change */
private FastVector m_Repainters = new FastVector();
/** An optional list of listeners who want to know when a colour
changes. Listeners are notified via an ActionEvent */
private FastVector m_ColourChangeListeners = new FastVector();
/** 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 steer away from setting up
* a color in the color list that is equal to the background color
*/
protected Color m_backgroundColor = null;
/** Inner Inner class used to create labels for nominal attributes
* so that there color can be changed.
*/
private class NomLabel
extends JLabel {
/** for serialization */
private static final long serialVersionUID = -4686613106474820655L;
private int m_index = 0;
/**
* Creates a label with its name and class index value.
* @param name The name of the nominal class value.
* @param id The index value for that class value.
*/
public NomLabel(String name, int id) {
super(name);
m_index = id;
this.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if ((e.getModifiers() & e.BUTTON1_MASK) == e.BUTTON1_MASK) {
Color tmp = JColorChooser.showDialog
(ClassPanel.this, "Select new Color",
(Color)m_colorList.elementAt(m_index));
if (tmp != null) {
m_colorList.setElementAt(tmp, m_index);
m_oldWidth = -9000;
ClassPanel.this.repaint();
if (m_Repainters.size() > 0) {
for (int i=0;i<m_Repainters.size();i++) {
((Component)(m_Repainters.elementAt(i))).repaint();
}
}
if (m_ColourChangeListeners.size() > 0) {
for (int i = 0; i < m_ColourChangeListeners.size(); i++) {
((ActionListener)(m_ColourChangeListeners.elementAt(i))).
actionPerformed(new ActionEvent(this, 0, ""));
}
}
}
}
}
});
}
}
public ClassPanel() {
this(null);
}
public ClassPanel(Color background) {
m_backgroundColor = background;
/** Set up some default colours */
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);
}
}
/**
* Adds a component that will need to be repainted if the user
* changes the colour of a label.
* @param c the component to be repainted
*/
public void addRepaintNotify(Component c) {
m_Repainters.addElement(c);
}
/**
* Add an action listener that will be notified if the user changes the
* colour of a label
*
* @param a an <code>ActionListener</code> value
*/
public void addActionListener(ActionListener a) {
m_ColourChangeListeners.addElement(a);
}
/**
* Set up fonts and font metrics
* @param gx the graphics context
*/
private void setFonts(Graphics gx) {
if (m_labelMetrics == null) {
m_labelFont = new Font("Monospaced", Font.PLAIN, 12);
m_labelMetrics = gx.getFontMetrics(m_labelFont);
int hf = m_labelMetrics.getAscent();
if (this.getHeight() < (3*hf)) {
m_labelFont = new Font("Monospaced",Font.PLAIN,11);
m_labelMetrics = gx.getFontMetrics(m_labelFont);
}
}
gx.setFont(m_labelFont);
}
/**
* Enables the panel
* @param e true to enable the panel
*/
public void setOn(boolean e) {
m_isEnabled = e;
}
/**
* Set the instances.
* @param insts the instances
*/
public void setInstances(Instances insts) {
m_Instances = insts;
}
/**
* Set the index of the attribute to display coloured labels for
* @param cIndex the index of the attribute to display coloured labels for
*/
public void setCindex(int cIndex) {
if (m_Instances.numAttributes() > 0) {
m_cIndex = cIndex;
if (m_Instances.attribute(m_cIndex).isNumeric()) {
setNumeric();
} else {
if (m_Instances.attribute(m_cIndex).numValues() > m_colorList.size()) {
extendColourMap();
}
setNominal();
}
}
}
/**
* Extends the list of colours if a new attribute with more values than
* the previous one is chosen
*/
private void extendColourMap() {
if (m_Instances.attribute(m_cIndex).isNominal()) {
for (int i = m_colorList.size();
i < m_Instances.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);
}
}
}
protected void setDefaultColourList(Color[] list) {
m_DefaultColors = list;
}
/**
* Set a list of colours to use for colouring labels
* @param cols a list containing java.awt.Colors
*/
public void setColours(FastVector cols) {
m_colorList = cols;
}
/**
* Sets the legend to be for a nominal variable
*/
protected void setNominal() {
m_isNumeric = false;
m_HorizontalPad = 0;
setOn(true);
m_oldWidth = -9000;
this.repaint();
}
/**
* Sets the legend to be for a numeric variable
*/
protected void setNumeric() {
m_isNumeric = true;
/* m_maxC = mxC;
m_minC = mnC; */
double min=Double.POSITIVE_INFINITY;
double max=Double.NEGATIVE_INFINITY;
double value;
for (int i=0;i<m_Instances.numInstances();i++) {
if (!m_Instances.instance(i).isMissing(m_cIndex)) {
value = m_Instances.instance(i).value(m_cIndex);
if (value < min) {
min = value;
}
if (value > max) {
max = value;
}
}
}
// handle case where all values are missing
if (min == Double.POSITIVE_INFINITY) min = max = 0.0;
m_minC = min; m_maxC = max;
int whole = (int)Math.abs(m_maxC);
double decimal = Math.abs(m_maxC) - whole;
int nondecimal;
nondecimal = (whole > 0)
? (int)(Math.log(whole) / Math.log(10))
: 1;
m_precisionC = (decimal > 0)
? (int)Math.abs(((Math.log(Math.abs(m_maxC)) /
Math.log(10))))+2
: 1;
if (m_precisionC > VisualizeUtils.MAX_PRECISION) {
m_precisionC = 1;
}
String maxStringC = Utils.doubleToString(m_maxC,
nondecimal+1+m_precisionC
,m_precisionC);
if (m_labelMetrics != null) {
m_HorizontalPad = m_labelMetrics.stringWidth(maxStringC);
}
whole = (int)Math.abs(m_minC);
decimal = Math.abs(m_minC) - whole;
nondecimal = (whole > 0)
? (int)(Math.log(whole) / Math.log(10))
: 1;
m_precisionC = (decimal > 0)
? (int)Math.abs(((Math.log(Math.abs(m_minC)) /
Math.log(10))))+2
: 1;
if (m_precisionC > VisualizeUtils.MAX_PRECISION) {
m_precisionC = 1;
}
maxStringC = Utils.doubleToString(m_minC,
nondecimal+1+m_precisionC
,m_precisionC);
if (m_labelMetrics != null) {
if (m_labelMetrics.stringWidth(maxStringC) > m_HorizontalPad) {
m_HorizontalPad = m_labelMetrics.stringWidth(maxStringC);
}
}
setOn(true);
this.repaint();
}
/**
* Renders the legend for a nominal colouring attribute
* @param gx the graphics context
*/
protected void paintNominal(Graphics gx) {
setFonts(gx);
int numClasses;
numClasses = m_Instances.attribute(m_cIndex).numValues();
int maxLabelLen = 0;
int idx=0;
int legendHeight;
int w = this.getWidth();
int hf = m_labelMetrics.getAscent();
for (int i=0;i<numClasses;i++) {
if (m_Instances.attribute(m_cIndex).value(i).length() >
maxLabelLen) {
maxLabelLen = m_Instances.
attribute(m_cIndex).value(i).length();
idx = i;
}
}
maxLabelLen = m_labelMetrics.stringWidth(m_Instances.
attribute(m_cIndex).value(idx));
if (((w-(2*m_HorizontalPad))/(maxLabelLen+5)) >= numClasses) {
legendHeight = 1;
} else {
legendHeight = 2;
}
int x = m_HorizontalPad;
int y = 1 + hf;
// do the first row
int ci, mp;
Color pc;
int numToDo = ((legendHeight==1) ? numClasses : (numClasses/2));
for (int i=0;i<numToDo;i++) {
gx.setColor((Color)m_colorList.elementAt(i));
// can we fit the full label or will each need to be trimmed?
if ((numToDo * maxLabelLen) > (w-(m_HorizontalPad*2))) {
String val;
val = m_Instances.attribute(m_cIndex).value(i);
int sw = m_labelMetrics.stringWidth(val);
int rm=0;
// truncate string if necessary
if (sw > ((w-(m_HorizontalPad*2)) / (numToDo))) {
int incr = (sw / val.length());
rm = (sw - ((w-(m_HorizontalPad*2)) / numToDo)) / incr;
if (rm <= 0) {
rm = 0;
}
if (rm >= val.length()) {
rm = val.length() - 1;
}
val = val.substring(0,val.length()-rm);
sw = m_labelMetrics.stringWidth(val);
}
NomLabel jj = new NomLabel(val, i);
jj.setFont(gx.getFont());
jj.setSize(m_labelMetrics.stringWidth(jj.getText()),
m_labelMetrics.getAscent() + 4);
this.add(jj);
jj.setLocation(x, y);
jj.setForeground((Color)m_colorList.
elementAt(i % m_colorList.size()));
x += sw + 2;
} else {
NomLabel jj;
jj = new NomLabel(m_Instances.attribute(m_cIndex).value(i), i);
jj.setFont(gx.getFont());
jj.setSize(m_labelMetrics.stringWidth(jj.getText()),
m_labelMetrics.getAscent() + 4);
this.add(jj);
jj.setLocation(x, y);
jj.setForeground((Color)m_colorList.
elementAt(i % m_colorList.size()));
x += ((w-(m_HorizontalPad*2)) / numToDo);
}
}
x = m_HorizontalPad;
y = 1+ hf + 5 +hf;
for (int i=numToDo;i<numClasses;i++) {
gx.setColor((Color)m_colorList.elementAt(i));
if (((numClasses-numToDo+1) * maxLabelLen) >
(w - (m_HorizontalPad*2))) {
String val;
val = m_Instances.attribute(m_cIndex).value(i);
int sw = m_labelMetrics.stringWidth(val);
int rm=0;
// truncate string if necessary
if (sw > ((w-(m_HorizontalPad*2)) / (numClasses-numToDo+1))) {
int incr = (sw / val.length());
rm = (sw - ((w-(m_HorizontalPad*2)) / (numClasses-numToDo)))
/ incr;
if (rm <= 0) {
rm = 0;
}
if (rm >= val.length()) {
rm = val.length() - 1;
}
val = val.substring(0,val.length()-rm);
sw = m_labelMetrics.stringWidth(val);
}
//this is the clipped string
NomLabel jj = new NomLabel(val, i);
jj.setFont(gx.getFont());
jj.setSize(m_labelMetrics.stringWidth(jj.getText()),
m_labelMetrics.getAscent() + 4);
this.add(jj);
jj.setLocation(x, y);
jj.setForeground((Color)m_colorList.
elementAt(i % m_colorList.size()));
x += sw +2;
} else {
//this is the full string
NomLabel jj;
jj = new NomLabel(m_Instances.attribute(m_cIndex).value(i), i);
jj.setFont(gx.getFont());
jj.setSize(m_labelMetrics.stringWidth(jj.getText()),
m_labelMetrics.getAscent() + 4);
this.add(jj);
jj.setLocation(x, y);
jj.setForeground((Color)m_colorList.
elementAt(i % m_colorList.size()));
x += ((w - (m_HorizontalPad*2)) / (numClasses-numToDo));
}
}
}
/**
* Renders the legend for a numeric colouring attribute
* @param gx the graphics context
*/
protected void paintNumeric(Graphics gx) {
setFonts(gx);
if (m_HorizontalPad == 0) {
setCindex(m_cIndex);
}
int w = this.getWidth();
double rs = 15;
double incr = 240.0 / (double)(w-(m_HorizontalPad*2));
int hf = m_labelMetrics.getAscent();
for (int i=m_HorizontalPad;i<
(w-m_HorizontalPad);i++) {
Color c = new Color((int)rs,150,(int)(255-rs));
gx.setColor(c);
gx.drawLine(i,0,
i,0+m_spectrumHeight);
rs += incr;
}
int whole = (int)Math.abs(m_maxC);
double decimal = Math.abs(m_maxC) - whole;
int nondecimal;
nondecimal = (whole > 0)
? (int)(Math.log(whole) / Math.log(10))
: 1;
m_precisionC = (decimal > 0)
? (int)Math.abs(((Math.log(Math.abs(m_maxC)) /
Math.log(10))))+2
: 1;
if (m_precisionC > VisualizeUtils.MAX_PRECISION) {
m_precisionC = 1;
}
String maxStringC = Utils.doubleToString(m_maxC,
nondecimal+1+m_precisionC
,m_precisionC);
int mswc = m_labelMetrics.stringWidth(maxStringC);
int tmsc = mswc;
if (w > (2 * tmsc)) {
gx.setColor(Color.black);
gx.drawLine(m_HorizontalPad,
(m_spectrumHeight+5),
w-m_HorizontalPad,
(m_spectrumHeight+5));
gx.drawLine(w-m_HorizontalPad,
(m_spectrumHeight+5),
w-m_HorizontalPad,
(m_spectrumHeight+5+m_tickSize));
gx.drawString(maxStringC,
(w-m_HorizontalPad)-(mswc/2),
(m_spectrumHeight+5+m_tickSize+hf));
gx.drawLine(m_HorizontalPad,
(m_spectrumHeight+5),
m_HorizontalPad,
(m_spectrumHeight+5+m_tickSize));
whole = (int)Math.abs(m_minC);
decimal = Math.abs(m_minC) - whole;
nondecimal = (whole > 0)
? (int)(Math.log(whole) / Math.log(10))
: 1;
m_precisionC = (decimal > 0)
? (int)Math.abs(((Math.log(Math.abs(m_minC)) /
Math.log(10))))+2
: 1;
if (m_precisionC > VisualizeUtils.MAX_PRECISION) {
m_precisionC = 1;
}
maxStringC = Utils.doubleToString(m_minC,
nondecimal+1+m_precisionC
,m_precisionC);
mswc = m_labelMetrics.stringWidth(maxStringC);
gx.drawString(maxStringC,
m_HorizontalPad-(mswc/2),
(m_spectrumHeight+5+m_tickSize+hf));
// draw the middle value if there is space
if (w > (3 * tmsc)) {
double mid = m_minC+((m_maxC-m_minC)/2.0);
gx.drawLine(m_HorizontalPad+((w-(2*m_HorizontalPad))/2),
(m_spectrumHeight+5),
m_HorizontalPad+((w-(2*m_HorizontalPad))/2),
(m_spectrumHeight+5+m_tickSize));
whole = (int)Math.abs(mid);
decimal = Math.abs(mid) - whole;
nondecimal = (whole > 0)
? (int)(Math.log(whole) / Math.log(10))
: 1;
m_precisionC = (decimal > 0)
? (int)Math.abs(((Math.log(Math.abs(mid)) /
Math.log(10))))+2
: 1;
if (m_precisionC > VisualizeUtils.MAX_PRECISION) {
m_precisionC = 1;
}
maxStringC = Utils.doubleToString(mid,
nondecimal+1+m_precisionC
,m_precisionC);
mswc = m_labelMetrics.stringWidth(maxStringC);
gx.drawString(maxStringC,
m_HorizontalPad+((w-(2*m_HorizontalPad))/2)-(mswc/2),
(m_spectrumHeight+5+m_tickSize+hf));
}
}
}
/**
* Renders this component
* @param gx the graphics context
*/
public void paintComponent(Graphics gx) {
super.paintComponent(gx);
if (m_isEnabled) {
if (m_isNumeric) {
m_oldWidth = -9000; //done so that if change back to nom, it will
//work
this.removeAll();
paintNumeric(gx);
} else {
if (m_Instances != null &&
m_Instances.numInstances() > 0 &&
m_Instances.numAttributes() > 0) {
if (m_oldWidth != this.getWidth()) {
this.removeAll();
m_oldWidth = this.getWidth();
paintNominal(gx);
}
}
}
}
}
/**
* Main method for testing this class.
* @param args first argument must specify an arff file. Second can
* specify an optional index to colour labels on
*/
public static void main(String [] args) {
try {
if (args.length < 1) {
System.err.println("Usage : weka.gui.visualize.ClassPanel <dataset> "
+"[class col]");
System.exit(1);
}
final javax.swing.JFrame jf =
new javax.swing.JFrame("Weka Explorer: Class");
jf.setSize(500,100);
jf.getContentPane().setLayout(new BorderLayout());
final ClassPanel p2 = new ClassPanel();
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());
}
}
}