/*
* 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.
*/
/*
* ModelPerformanceChart.java
* Copyright (C) 2004 University of Waikato, Hamilton, New Zealand
*
*/
package weka.gui.beans;
import java.awt.BorderLayout;
import java.awt.GraphicsEnvironment;
import java.awt.image.BufferedImage;
import java.beans.EventSetDescriptor;
import java.beans.PropertyChangeListener;
import java.beans.VetoableChangeListener;
import java.beans.beancontext.BeanContext;
import java.beans.beancontext.BeanContextChild;
import java.beans.beancontext.BeanContextChildSupport;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.EventObject;
import java.util.List;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JPanel;
import weka.core.Attribute;
import weka.core.DenseInstance;
import weka.core.Environment;
import weka.core.EnvironmentHandler;
import weka.core.FastVector;
import weka.core.Instance;
import weka.core.Instances;
import weka.gui.Logger;
import weka.gui.visualize.Plot2D;
import weka.gui.visualize.PlotData2D;
import weka.gui.visualize.VisualizePanel;
/**
* Bean that can be used for displaying threshold curves (e.g. ROC
* curves) and scheme error plots
*
* @author Mark Hall
* @version $Revision: 7748 $
*/
public class ModelPerformanceChart
extends JPanel
implements ThresholdDataListener, VisualizableErrorListener,
Visible, UserRequestAcceptor, EventConstraints,
Serializable, BeanContextChild, HeadlessEventCollector,
BeanCommon, EnvironmentHandler {
/** for serialization */
private static final long serialVersionUID = -4602034200071195924L;
protected BeanVisual m_visual = new BeanVisual("ModelPerformanceChart",
BeanVisual.ICON_PATH+"ModelPerformanceChart.gif",
BeanVisual.ICON_PATH
+"ModelPerformanceChart_animated.gif");
protected transient PlotData2D m_masterPlot;
/** For rendering plots to encapsulate in ImageEvents */
protected transient List<Instances> m_offscreenPlotData;
protected transient List<String> m_thresholdSeriesTitles;
protected transient OffscreenChartRenderer m_offscreenRenderer;
/** Name of the renderer to use for offscreen chart rendering */
protected String m_offscreenRendererName = "Weka Chart Renderer";
/**
* The name of the attribute to use for the x-axis of offscreen plots.
* If left empty, False Positive Rate is used for threshold curves
*/
protected String m_xAxis = "";
/**
* The name of the attribute to use for the y-axis of offscreen plots.
* If left empty, True Positive Rate is used for threshold curves
*/
protected String m_yAxis = "";
/**
* Additional options for the offscreen renderer
*/
protected String m_additionalOptions = "";
/** Width of offscreen plots */
protected String m_width = "500";
/** Height of offscreen plots */
protected String m_height = "400";
protected transient JFrame m_popupFrame;
protected boolean m_framePoppedUp = false;
/** Events received and stored during headless execution */
protected List<EventObject> m_headlessEvents;
/**
* Set to true when processing events stored during headless
* execution. Used to prevent sending ImageEvents to listeners
* a second time (since these will have been passed on during
* headless execution).
*/
protected transient boolean m_processingHeadlessEvents = false;
protected ArrayList<ImageListener> m_imageListeners = new ArrayList<ImageListener>();
protected List<Object> m_listenees = new ArrayList<Object>();
/**
* True if this bean's appearance is the design mode appearance
*/
protected boolean m_design;
/**
* BeanContex that this bean might be contained within
*/
protected transient BeanContext m_beanContext = null;
private transient VisualizePanel m_visPanel;
/**
* The environment variables.
*/
protected transient Environment m_env;
/**
* BeanContextChild support
*/
protected BeanContextChildSupport m_bcSupport =
new BeanContextChildSupport(this);
public ModelPerformanceChart() {
useDefaultVisual();
java.awt.GraphicsEnvironment ge =
java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment();
if (!ge.isHeadless()) {
appearanceFinal();
} else {
m_headlessEvents = new ArrayList<EventObject>();
}
}
/**
* Global info for this bean
*
* @return a <code>String</code> value
*/
public String globalInfo() {
return "Visualize performance charts (such as ROC).";
}
protected void appearanceDesign() {
removeAll();
setLayout(new BorderLayout());
add(m_visual, BorderLayout.CENTER);
}
protected void appearanceFinal() {
removeAll();
setLayout(new BorderLayout());
setUpFinal();
}
protected void setUpFinal() {
if (m_visPanel == null) {
m_visPanel = new VisualizePanel();
}
add(m_visPanel, BorderLayout.CENTER);
}
protected void setupOffscreenRenderer() {
if (m_offscreenRenderer == null) {
if (m_offscreenRendererName == null || m_offscreenRendererName.length() == 0) {
m_offscreenRenderer = new WekaOffscreenChartRenderer();
return;
}
if (m_offscreenRendererName.equalsIgnoreCase("weka chart renderer")) {
m_offscreenRenderer = new WekaOffscreenChartRenderer();
} else {
try {
Object r = PluginManager.getPluginInstance("weka.gui.beans.OffscreenChartRenderer",
m_offscreenRendererName);
if (r != null && r instanceof weka.gui.beans.OffscreenChartRenderer) {
m_offscreenRenderer = (OffscreenChartRenderer)r;
} else {
// use built-in default
m_offscreenRenderer = new WekaOffscreenChartRenderer();
}
} catch (Exception ex) {
// use built-in default
m_offscreenRenderer = new WekaOffscreenChartRenderer();
}
}
}
}
/**
* Display a threshold curve.
*
* @param e a ThresholdDataEvent
*/
public synchronized void acceptDataSet(ThresholdDataEvent e) {
if (m_env == null) {
m_env = Environment.getSystemWide();
}
if (!GraphicsEnvironment.isHeadless()) {
if (m_visPanel == null) {
m_visPanel = new VisualizePanel();
}
if (m_masterPlot == null) {
m_masterPlot = e.getDataSet();
}
try {
// check for compatable data sets
if (!m_masterPlot.getPlotInstances().relationName().
equals(e.getDataSet().getPlotInstances().relationName())) {
// if not equal then remove all plots and set as new master plot
m_masterPlot = e.getDataSet();
m_visPanel.setMasterPlot(m_masterPlot);
m_visPanel.validate(); m_visPanel.repaint();
} else {
// add as new plot
m_visPanel.addPlot(e.getDataSet());
m_visPanel.validate(); m_visPanel.repaint();
}
m_visPanel.setXIndex(4); m_visPanel.setYIndex(5);
} catch (Exception ex) {
System.err.println("Problem setting up visualization (ModelPerformanceChart)");
ex.printStackTrace();
}
} else {
m_headlessEvents.add(e);
}
if (m_imageListeners.size() > 0 && !m_processingHeadlessEvents) {
// configure the renderer (if necessary)
setupOffscreenRenderer();
if (m_offscreenPlotData == null ||
!m_offscreenPlotData.get(0).relationName().
equals(e.getDataSet().getPlotInstances().relationName())) {
m_offscreenPlotData = new ArrayList<Instances>();
m_thresholdSeriesTitles = new ArrayList<String>();
}
m_offscreenPlotData.add(e.getDataSet().getPlotInstances());
m_thresholdSeriesTitles.add(e.getDataSet().getPlotName());
List<String> options = new ArrayList<String>();
String additional = "-color=/last";
if (m_additionalOptions != null && m_additionalOptions.length() > 0) {
additional = m_additionalOptions;
try {
additional = m_env.substitute(additional);
} catch (Exception ex) { }
}
String[] optsParts = additional.split(",");
for (String p : optsParts) {
options.add(p.trim());
}
String xAxis = "False Positive Rate";
if (m_xAxis != null && m_xAxis.length() > 0) {
xAxis = m_xAxis;
try {
xAxis = m_env.substitute(xAxis);
} catch (Exception ex) { }
}
String yAxis = "True Positive Rate";
if (m_yAxis != null && m_yAxis.length() > 0) {
yAxis = m_yAxis;
try {
yAxis = m_env.substitute(yAxis);
} catch (Exception ex) { }
}
String width = m_width;
String height = m_height;
int defWidth = 500;
int defHeight = 400;
try {
width = m_env.substitute(width);
height = m_env.substitute(height);
defWidth = Integer.parseInt(width);
defHeight = Integer.parseInt(height);
} catch (Exception ex) { }
try {
List<Instances> series = new ArrayList<Instances>();
for (int i = 0; i < m_offscreenPlotData.size(); i++) {
Instances temp = new Instances(m_offscreenPlotData.get(i));
// set relation name to scheme name
temp.setRelationName(m_thresholdSeriesTitles.get(i));
series.add(temp);
}
BufferedImage osi = m_offscreenRenderer.renderXYLineChart(defWidth, defHeight,
series, xAxis, yAxis, options);
ImageEvent ie = new ImageEvent(this, osi);
notifyImageListeners(ie);
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
/**
* Display a scheme error plot.
*
* @param e a VisualizableErrorEvent
*/
public synchronized void acceptDataSet(VisualizableErrorEvent e) {
if (m_env == null) {
m_env = Environment.getSystemWide();
}
if (!GraphicsEnvironment.isHeadless()) {
if (m_visPanel == null) {
m_visPanel = new VisualizePanel();
}
if (m_masterPlot == null) {
m_masterPlot = e.getDataSet();
}
try {
m_visPanel.setMasterPlot(m_masterPlot);
} catch (Exception ex) {
System.err.println("Problem setting up visualization (ModelPerformanceChart)");
ex.printStackTrace();
}
m_visPanel.validate();
m_visPanel.repaint();
} else {
m_headlessEvents = new ArrayList<EventObject>();
m_headlessEvents.add(e);
}
if (m_imageListeners.size() > 0 && !m_processingHeadlessEvents) {
// configure the renderer (if necessary)
setupOffscreenRenderer();
m_offscreenPlotData = new ArrayList<Instances>();
Instances predictedI = e.getDataSet().getPlotInstances();
if (predictedI.classAttribute().isNominal()) {
// split the classes out into individual series.
// add a new attribute to hold point sizes - correctly
// classified instances get default point size (2);
// misclassified instances get point size (5).
// WekaOffscreenChartRenderer can take advantage of this
// information - other plugin renderers may or may not
// be able to use it
FastVector atts = new FastVector();
for (int i = 0; i < predictedI.numAttributes(); i++) {
atts.add(predictedI.attribute(i).copy());
}
atts.add(new Attribute("@@size@@"));
Instances newInsts = new Instances(predictedI.relationName(),
atts, predictedI.numInstances());
newInsts.setClassIndex(predictedI.classIndex());
for (int i = 0; i < predictedI.numInstances(); i++) {
double[] vals = new double[newInsts.numAttributes()];
for (int j = 0; j < predictedI.numAttributes(); j++) {
vals[j] = predictedI.instance(i).value(j);
}
vals[vals.length - 1] = 2; // default shape size
Instance ni = new DenseInstance(1.0, vals);
newInsts.add(ni);
}
// predicted class attribute is always actualClassIndex - 1
Instances[] classes = new Instances[newInsts.numClasses()];
for (int i = 0; i < newInsts.numClasses(); i++) {
classes[i] = new Instances(newInsts, 0);
classes[i].setRelationName(newInsts.classAttribute().value(i));
}
Instances errors = new Instances(newInsts, 0);
int actualClass = newInsts.classIndex();
for (int i = 0; i < newInsts.numInstances(); i++) {
Instance current = newInsts.instance(i);
classes[(int)current.classValue()].add((Instance)current.copy());
if (current.value(actualClass) != current.value(actualClass - 1)) {
Instance toAdd = (Instance)current.copy();
// larger shape for an error
toAdd.setValue(toAdd.numAttributes() - 1, 5);
// swap predicted and actual class value so
// that the color plotted for the error series
// is that of the predicted class
double actualClassV = toAdd.value(actualClass);
double predictedClassV = toAdd.value(actualClass - 1);
toAdd.setValue(actualClass, predictedClassV);
toAdd.setValue(actualClass - 1, actualClassV);
errors.add(toAdd);
}
}
errors.setRelationName("Errors");
m_offscreenPlotData.add(errors);
for (int i = 0; i < classes.length; i++) {
m_offscreenPlotData.add(classes[i]);
}
} else {
// numeric class - have to make a new set of instances
// with the point sizes added as an additional attribute
FastVector atts = new FastVector();
for (int i = 0; i < predictedI.numAttributes(); i++) {
atts.add(predictedI.attribute(i).copy());
}
atts.add(new Attribute("@@size@@"));
Instances newInsts = new Instances(predictedI.relationName(),
atts, predictedI.numInstances());
int[] shapeSizes = e.getDataSet().getShapeSize();
for (int i = 0; i < predictedI.numInstances(); i++) {
double[] vals = new double[newInsts.numAttributes()];
for (int j = 0; j < predictedI.numAttributes(); j++) {
vals[j] = predictedI.instance(i).value(j);
}
vals[vals.length - 1] = shapeSizes[i];
Instance ni = new DenseInstance(1.0, vals);
newInsts.add(ni);
}
newInsts.setRelationName(predictedI.classAttribute().name());
m_offscreenPlotData.add(newInsts);
}
List<String> options = new ArrayList<String>();
String additional = "-color=" + predictedI.classAttribute().name()
+ ",-hasErrors";
if (m_additionalOptions != null && m_additionalOptions.length() > 0) {
additional += "," + m_additionalOptions;
try {
additional = m_env.substitute(additional);
} catch (Exception ex) { }
}
String[] optionsParts = additional.split(",");
for (String p : optionsParts) {
options.add(p.trim());
}
// if (predictedI.classAttribute().isNumeric()) {
options.add("-shapeSize=@@size@@");
// }
String xAxis = m_xAxis;
try {
xAxis = m_env.substitute(xAxis);
} catch (Exception ex) { }
String yAxis = m_yAxis;
try {
yAxis = m_env.substitute(yAxis);
} catch (Exception ex) { }
String width = m_width;
String height = m_height;
int defWidth = 500;
int defHeight = 400;
try {
width = m_env.substitute(width);
height = m_env.substitute(height);
defWidth = Integer.parseInt(width);
defHeight = Integer.parseInt(height);
} catch (Exception ex) { }
try {
BufferedImage osi = m_offscreenRenderer.renderXYScatterPlot(defWidth, defHeight,
m_offscreenPlotData, xAxis, yAxis, options);
ImageEvent ie = new ImageEvent(this, osi);
notifyImageListeners(ie);
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
/**
* Notify all text listeners of a TextEvent
*
* @param te a <code>ImageEvent</code> value
*/
@SuppressWarnings("unchecked")
private void notifyImageListeners(ImageEvent te) {
ArrayList<ImageListener> l;
synchronized (this) {
l = (ArrayList<ImageListener>)m_imageListeners.clone();
}
if (l.size() > 0) {
for(int i = 0; i < l.size(); i++) {
l.get(i).acceptImage(te);
}
}
}
/**
* Get the list of events processed in headless mode. May return
* null or an empty list if not running in headless mode or no
* events were processed
*
* @return a list of EventObjects or null.
*/
public List<EventObject> retrieveHeadlessEvents() {
return m_headlessEvents;
}
/**
* Process a list of events that have been collected earlier. Has
* no affect if the component is running in headless mode.
*
* @param headless a list of EventObjects to process.
*/
public void processHeadlessEvents(List<EventObject> headless) {
// only process if we're not headless
if (!GraphicsEnvironment.isHeadless()) {
m_processingHeadlessEvents = true;
for (EventObject e : headless) {
if (e instanceof ThresholdDataEvent) {
acceptDataSet((ThresholdDataEvent)e);
} else if (e instanceof VisualizableErrorEvent) {
acceptDataSet((VisualizableErrorEvent)e);
}
}
}
m_processingHeadlessEvents = false;
}
/**
* Set the visual appearance of this bean
*
* @param newVisual a <code>BeanVisual</code> value
*/
public void setVisual(BeanVisual newVisual) {
m_visual = newVisual;
}
/**
* Return the visual appearance of this bean
*/
public BeanVisual getVisual() {
return m_visual;
}
/**
* Use the default appearance for this bean
*/
public void useDefaultVisual() {
m_visual.loadIcons(BeanVisual.ICON_PATH+"ModelPerformanceChart.gif",
BeanVisual.ICON_PATH+"ModelPerformanceChart_animated.gif");
}
/**
* Describe <code>enumerateRequests</code> method here.
*
* @return an <code>Enumeration</code> value
*/
public Enumeration enumerateRequests() {
Vector newVector = new Vector(0);
if (m_masterPlot != null) {
newVector.addElement("Show chart");
newVector.addElement("?Clear all plots");
}
return newVector.elements();
}
/**
* Add a property change listener to this bean
*
* @param name the name of the property of interest
* @param pcl a <code>PropertyChangeListener</code> value
*/
public void addPropertyChangeListener(String name,
PropertyChangeListener pcl) {
m_bcSupport.addPropertyChangeListener(name, pcl);
}
/**
* Remove a property change listener from this bean
*
* @param name the name of the property of interest
* @param pcl a <code>PropertyChangeListener</code> value
*/
public void removePropertyChangeListener(String name,
PropertyChangeListener pcl) {
m_bcSupport.removePropertyChangeListener(name, pcl);
}
/**
* Add a vetoable change listener to this bean
*
* @param name the name of the property of interest
* @param vcl a <code>VetoableChangeListener</code> value
*/
public void addVetoableChangeListener(String name,
VetoableChangeListener vcl) {
m_bcSupport.addVetoableChangeListener(name, vcl);
}
/**
* Remove a vetoable change listener from this bean
*
* @param name the name of the property of interest
* @param vcl a <code>VetoableChangeListener</code> value
*/
public void removeVetoableChangeListener(String name,
VetoableChangeListener vcl) {
m_bcSupport.removeVetoableChangeListener(name, vcl);
}
/**
* Set a bean context for this bean
*
* @param bc a <code>BeanContext</code> value
*/
public void setBeanContext(BeanContext bc) {
m_beanContext = bc;
m_design = m_beanContext.isDesignTime();
if (m_design) {
appearanceDesign();
} else {
java.awt.GraphicsEnvironment ge =
java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment();
if (!ge.isHeadless()) {
appearanceFinal();
}
}
}
/**
* Return the bean context (if any) that this bean is embedded in
*
* @return a <code>BeanContext</code> value
*/
public BeanContext getBeanContext() {
return m_beanContext;
}
/**
* Describe <code>performRequest</code> method here.
*
* @param request a <code>String</code> value
* @exception IllegalArgumentException if an error occurs
*/
public void performRequest(String request) {
if (request.compareTo("Show chart") == 0) {
try {
// popup visualize panel
if (!m_framePoppedUp) {
m_framePoppedUp = true;
final javax.swing.JFrame jf =
new javax.swing.JFrame("Model Performance Chart");
jf.setSize(800,600);
jf.getContentPane().setLayout(new BorderLayout());
jf.getContentPane().add(m_visPanel, BorderLayout.CENTER);
jf.addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent e) {
jf.dispose();
m_framePoppedUp = false;
}
});
jf.setVisible(true);
m_popupFrame = jf;
} else {
m_popupFrame.toFront();
}
} catch (Exception ex) {
ex.printStackTrace();
m_framePoppedUp = false;
}
} else if (request.equals("Clear all plots")) {
m_visPanel.removeAllPlots();
m_visPanel.validate(); m_visPanel.repaint();
m_visPanel = null;
m_masterPlot = null;
m_offscreenPlotData = null;
} else {
throw new IllegalArgumentException(request
+ " not supported (Model Performance Chart)");
}
}
public static void main(String [] args) {
try {
if (args.length != 1) {
System.err.println("Usage: ModelPerformanceChart <dataset>");
System.exit(1);
}
java.io.Reader r = new java.io.BufferedReader(
new java.io.FileReader(args[0]));
Instances inst = new Instances(r);
final javax.swing.JFrame jf = new javax.swing.JFrame();
jf.getContentPane().setLayout(new java.awt.BorderLayout());
final ModelPerformanceChart as = new ModelPerformanceChart();
PlotData2D pd = new PlotData2D(inst);
pd.setPlotName(inst.relationName());
ThresholdDataEvent roc = new ThresholdDataEvent(as, pd);
as.acceptDataSet(roc);
jf.getContentPane().add(as, java.awt.BorderLayout.CENTER);
jf.addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent e) {
jf.dispose();
System.exit(0);
}
});
jf.setSize(800,600);
jf.setVisible(true);
} catch (Exception ex) {
ex.printStackTrace();
System.err.println(ex.getMessage());
}
}
/**
* Set a custom (descriptive) name for this bean
*
* @param name the name to use
*/
public void setCustomName(String name) {
m_visual.setText(name);
}
/**
* Get the custom (descriptive) name for this bean (if one has been set)
*
* @return the custom name (or the default name)
*/
public String getCustomName() {
return m_visual.getText();
}
/**
* Stop any processing that the bean might be doing.
*/
public void stop() {
}
/**
* Returns true if. at this time, the bean is busy with some
* (i.e. perhaps a worker thread is performing some calculation).
*
* @return true if the bean is busy.
*/
public boolean isBusy() {
return false;
}
/**
* Add an image listener
*
* @param cl a <code>ImageListener</code> value
*/
public synchronized void addImageListener(ImageListener cl) {
m_imageListeners.add(cl);
}
/**
* Remove an image listener
*
* @param cl a <code>ImageListener</code> value
*/
public synchronized void removeImageListener(ImageListener cl) {
m_imageListeners.remove(cl);
}
/**
* Set a logger
*
* @param logger a <code>Logger</code> value
*/
public void setLog(Logger logger) {
}
/**
* Returns true if, at this time,
* the object will accept a connection via the supplied
* EventSetDescriptor
*
* @param esd the EventSetDescriptor
* @return true if the object will accept a connection
*/
public boolean connectionAllowed(EventSetDescriptor esd) {
return connectionAllowed(esd.getName());
}
/**
* Returns true if, at this time,
* the object will accept a connection via the named event
*
* @param eventName the name of the event
* @return true if the object will accept a connection
*/
public boolean connectionAllowed(String eventName) {
return eventName.equals("thresholdData") || eventName.equals("visualizableError");
}
/**
* Notify this object that it has been registered as a listener with
* a source for recieving events described by the named event
* This object is responsible for recording this fact.
*
* @param eventName the event
* @param source the source with which this object has been registered as
* a listener
*/
public void connectionNotification(String eventName, Object source) {
if (connectionAllowed(eventName)) {
m_listenees.add(source);
}
}
/**
* Notify this object that it has been deregistered as a listener with
* a source for named event. This object is responsible
* for recording this fact.
*
* @param eventName the event
* @param source the source with which this object has been registered as
* a listener
*/
public void disconnectionNotification(String eventName, Object source) {
m_listenees.remove(source);
}
/**
* Returns true, if at the current time, the named event could
* be generated. Assumes that supplied event names are names of
* events that could be generated by this bean.
*
* @param eventName the name of the event in question
* @return true if the named event could be generated at this point in
* time
*/
public boolean eventGeneratable(String eventName) {
if (m_listenees.size() == 0) {
return false;
}
boolean ok = false;
for (Object o : m_listenees) {
if (o instanceof EventConstraints) {
if (((EventConstraints)o).eventGeneratable("thresholdData") ||
((EventConstraints)o).eventGeneratable("visualizableError")) {
ok = true;
break;
}
}
}
return ok;
}
@Override
public void setEnvironment(Environment env) {
m_env = env;
}
/**
* Set the name of the attribute for the x-axis in offscreen plots. This defaults
* to "False Positive Rate" for threshold curves if not specified.
*
* @param xAxis the name of the xAxis
*/
public void setOffscreenXAxis(String xAxis) {
m_xAxis = xAxis;
}
/**
* Get the name of the attribute for the x-axis in offscreen plots
*
* @return the name of the xAxis
*/
public String getOffscreenXAxis() {
return m_xAxis;
}
/**
* Set the name of the attribute for the y-axis in offscreen plots. This defaults
* to "True Positive Rate" for threshold curves if not specified.
*
* @param yAxis the name of the xAxis
*/
public void setOffscreenYAxis(String yAxis) {
m_yAxis = yAxis;
}
/**
* Get the name of the attribute for the y-axix of offscreen plots.
*
* @return the name of the yAxis.
*/
public String getOffscreenYAxis() {
return m_yAxis;
}
/**
* Set the width (in pixels) of the offscreen image to generate.
*
* @param width the width in pixels.
*/
public void setOffscreenWidth(String width) {
m_width = width;
}
/**
* Get the width (in pixels) of the offscreen image to generate.
*
* @return the width in pixels.
*/
public String getOffscreenWidth() {
return m_width;
}
/**
* Set the height (in pixels) of the offscreen image to generate
*
* @param height the height in pixels
*/
public void setOffscreenHeight(String height) {
m_height = height;
}
/**
* Get the height (in pixels) of the offscreen image to generate
* @return the height in pixels
*/
public String getOffscreenHeight() {
return m_height;
}
/**
* Set the name of the renderer to use for offscreen chart
* rendering operations
*
* @param rendererName the name of the renderer to use
*/
public void setOffscreenRendererName(String rendererName) {
m_offscreenRendererName = rendererName;
m_offscreenRenderer = null;
}
/**
* Get the name of the renderer to use for offscreen chart
* rendering operations
*
* @return the name of the renderer to use
*/
public String getOffscreenRendererName() {
return m_offscreenRendererName;
}
/**
* Set the additional options for the offscreen renderer
*
* @param additional additional options
*/
public void setOffscreenAdditionalOpts(String additional) {
m_additionalOptions = additional;
}
/**
* Get the additional options for the offscreen renderer
*
* @return the additional options
*/
public String getOffscreenAdditionalOpts() {
return m_additionalOptions;
}
}