|
|
jfreechart example source code file (FastScatterPlot.java)
This example jfreechart source code file (FastScatterPlot.java) is included in the DevDaily.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.
The jfreechart FastScatterPlot.java source code
/* ===========================================================
* JFreeChart : a free chart library for the Java(tm) platform
* ===========================================================
*
* (C) Copyright 2000-2009, by Object Refinery Limited and Contributors.
*
* Project Info: http://www.jfree.org/jfreechart/index.html
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This library 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 Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* --------------------
* FastScatterPlot.java
* --------------------
* (C) Copyright 2002-2009, by Object Refinery Limited.
*
* Original Author: David Gilbert (for Object Refinery Limited);
* Contributor(s): Arnaud Lelievre;
*
* Changes
* -------
* 29-Oct-2002 : Added standard header (DG);
* 07-Nov-2002 : Fixed errors reported by Checkstyle (DG);
* 26-Mar-2003 : Implemented Serializable (DG);
* 19-Aug-2003 : Implemented Cloneable (DG);
* 08-Sep-2003 : Added internationalization via use of properties
* resourceBundle (RFE 690236) (AL);
* 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG);
* 12-Nov-2003 : Implemented zooming (DG);
* 21-Jan-2004 : Update for renamed method in ValueAxis (DG);
* 26-Jan-2004 : Added domain and range grid lines (DG);
* 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG);
* 29-Sep-2004 : Removed hard-coded color (DG);
* 04-Oct-2004 : Reworked equals() method and renamed ArrayUtils
* --> ArrayUtilities (DG);
* 12-Nov-2004 : Implemented the new Zoomable interface (DG);
* 05-May-2005 : Updated draw() method parameters (DG);
* 16-Jun-2005 : Added get/setData() methods (DG);
* ------------- JFREECHART 1.0.x ---------------------------------------------
* 10-Nov-2006 : Fixed bug 1593150, by not allowing null axes, and added
* setDomainAxis() and setRangeAxis() methods (DG);
* 24-Sep-2007 : Implemented new zooming methods (DG);
* 25-Mar-2008 : Make use of new fireChangeEvent() method (DG);
* 18-Dec-2008 : Use ResourceBundleWrapper - see patch 1607918 by
* Jess Thrysoee (DG);
* 26-Mar-2009 : Implemented Pannable, and fixed bug in zooming (DG);
*
*/
package org.jfree.chart.plot;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.ResourceBundle;
import org.jfree.chart.axis.AxisSpace;
import org.jfree.chart.axis.AxisState;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.axis.ValueTick;
import org.jfree.chart.event.PlotChangeEvent;
import org.jfree.chart.util.ResourceBundleWrapper;
import org.jfree.data.Range;
import org.jfree.io.SerialUtilities;
import org.jfree.ui.RectangleEdge;
import org.jfree.ui.RectangleInsets;
import org.jfree.util.ArrayUtilities;
import org.jfree.util.ObjectUtilities;
import org.jfree.util.PaintUtilities;
/**
* A fast scatter plot.
*/
public class FastScatterPlot extends Plot implements ValueAxisPlot, Pannable,
Zoomable, Cloneable, Serializable {
/** For serialization. */
private static final long serialVersionUID = 7871545897358563521L;
/** The default grid line stroke. */
public static final Stroke DEFAULT_GRIDLINE_STROKE = new BasicStroke(0.5f,
BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0.0f, new float[]
{2.0f, 2.0f}, 0.0f);
/** The default grid line paint. */
public static final Paint DEFAULT_GRIDLINE_PAINT = Color.lightGray;
/** The data. */
private float[][] data;
/** The x data range. */
private Range xDataRange;
/** The y data range. */
private Range yDataRange;
/** The domain axis (used for the x-values). */
private ValueAxis domainAxis;
/** The range axis (used for the y-values). */
private ValueAxis rangeAxis;
/** The paint used to plot data points. */
private transient Paint paint;
/** A flag that controls whether the domain grid-lines are visible. */
private boolean domainGridlinesVisible;
/** The stroke used to draw the domain grid-lines. */
private transient Stroke domainGridlineStroke;
/** The paint used to draw the domain grid-lines. */
private transient Paint domainGridlinePaint;
/** A flag that controls whether the range grid-lines are visible. */
private boolean rangeGridlinesVisible;
/** The stroke used to draw the range grid-lines. */
private transient Stroke rangeGridlineStroke;
/** The paint used to draw the range grid-lines. */
private transient Paint rangeGridlinePaint;
/**
* A flag that controls whether or not panning is enabled for the domain
* axis.
*
* @since 1.0.13
*/
private boolean domainPannable;
/**
* A flag that controls whether or not panning is enabled for the range
* axis.
*
* @since 1.0.13
*/
private boolean rangePannable;
/** The resourceBundle for the localization. */
protected static ResourceBundle localizationResources
= ResourceBundleWrapper.getBundle(
"org.jfree.chart.plot.LocalizationBundle");
/**
* Creates a new instance of <code>FastScatterPlot with default
* axes.
*/
public FastScatterPlot() {
this(null, new NumberAxis("X"), new NumberAxis("Y"));
}
/**
* Creates a new fast scatter plot.
* <p>
* The data is an array of x, y values: data[0][i] = x, data[1][i] = y.
*
* @param data the data (<code>null permitted).
* @param domainAxis the domain (x) axis (<code>null not permitted).
* @param rangeAxis the range (y) axis (<code>null not permitted).
*/
public FastScatterPlot(float[][] data,
ValueAxis domainAxis, ValueAxis rangeAxis) {
super();
if (domainAxis == null) {
throw new IllegalArgumentException("Null 'domainAxis' argument.");
}
if (rangeAxis == null) {
throw new IllegalArgumentException("Null 'rangeAxis' argument.");
}
this.data = data;
this.xDataRange = calculateXDataRange(data);
this.yDataRange = calculateYDataRange(data);
this.domainAxis = domainAxis;
this.domainAxis.setPlot(this);
this.domainAxis.addChangeListener(this);
this.rangeAxis = rangeAxis;
this.rangeAxis.setPlot(this);
this.rangeAxis.addChangeListener(this);
this.paint = Color.red;
this.domainGridlinesVisible = true;
this.domainGridlinePaint = FastScatterPlot.DEFAULT_GRIDLINE_PAINT;
this.domainGridlineStroke = FastScatterPlot.DEFAULT_GRIDLINE_STROKE;
this.rangeGridlinesVisible = true;
this.rangeGridlinePaint = FastScatterPlot.DEFAULT_GRIDLINE_PAINT;
this.rangeGridlineStroke = FastScatterPlot.DEFAULT_GRIDLINE_STROKE;
}
/**
* Returns a short string describing the plot type.
*
* @return A short string describing the plot type.
*/
public String getPlotType() {
return localizationResources.getString("Fast_Scatter_Plot");
}
/**
* Returns the data array used by the plot.
*
* @return The data array (possibly <code>null).
*
* @see #setData(float[][])
*/
public float[][] getData() {
return this.data;
}
/**
* Sets the data array used by the plot and sends a {@link PlotChangeEvent}
* to all registered listeners.
*
* @param data the data array (<code>null permitted).
*
* @see #getData()
*/
public void setData(float[][] data) {
this.data = data;
fireChangeEvent();
}
/**
* Returns the orientation of the plot.
*
* @return The orientation (always {@link PlotOrientation#VERTICAL}).
*/
public PlotOrientation getOrientation() {
return PlotOrientation.VERTICAL;
}
/**
* Returns the domain axis for the plot.
*
* @return The domain axis (never <code>null).
*
* @see #setDomainAxis(ValueAxis)
*/
public ValueAxis getDomainAxis() {
return this.domainAxis;
}
/**
* Sets the domain axis and sends a {@link PlotChangeEvent} to all
* registered listeners.
*
* @param axis the axis (<code>null not permitted).
*
* @since 1.0.3
*
* @see #getDomainAxis()
*/
public void setDomainAxis(ValueAxis axis) {
if (axis == null) {
throw new IllegalArgumentException("Null 'axis' argument.");
}
this.domainAxis = axis;
fireChangeEvent();
}
/**
* Returns the range axis for the plot.
*
* @return The range axis (never <code>null).
*
* @see #setRangeAxis(ValueAxis)
*/
public ValueAxis getRangeAxis() {
return this.rangeAxis;
}
/**
* Sets the range axis and sends a {@link PlotChangeEvent} to all
* registered listeners.
*
* @param axis the axis (<code>null not permitted).
*
* @since 1.0.3
*
* @see #getRangeAxis()
*/
public void setRangeAxis(ValueAxis axis) {
if (axis == null) {
throw new IllegalArgumentException("Null 'axis' argument.");
}
this.rangeAxis = axis;
fireChangeEvent();
}
/**
* Returns the paint used to plot data points. The default is
* <code>Color.red.
*
* @return The paint.
*
* @see #setPaint(Paint)
*/
public Paint getPaint() {
return this.paint;
}
/**
* Sets the color for the data points and sends a {@link PlotChangeEvent}
* to all registered listeners.
*
* @param paint the paint (<code>null not permitted).
*
* @see #getPaint()
*/
public void setPaint(Paint paint) {
if (paint == null) {
throw new IllegalArgumentException("Null 'paint' argument.");
}
this.paint = paint;
fireChangeEvent();
}
/**
* Returns <code>true if the domain gridlines are visible, and
* <code>false otherwise.
*
* @return <code>true or false.
*
* @see #setDomainGridlinesVisible(boolean)
* @see #setDomainGridlinePaint(Paint)
*/
public boolean isDomainGridlinesVisible() {
return this.domainGridlinesVisible;
}
/**
* Sets the flag that controls whether or not the domain grid-lines are
* visible. If the flag value is changed, a {@link PlotChangeEvent} is
* sent to all registered listeners.
*
* @param visible the new value of the flag.
*
* @see #getDomainGridlinePaint()
*/
public void setDomainGridlinesVisible(boolean visible) {
if (this.domainGridlinesVisible != visible) {
this.domainGridlinesVisible = visible;
fireChangeEvent();
}
}
/**
* Returns the stroke for the grid-lines (if any) plotted against the
* domain axis.
*
* @return The stroke (never <code>null).
*
* @see #setDomainGridlineStroke(Stroke)
*/
public Stroke getDomainGridlineStroke() {
return this.domainGridlineStroke;
}
/**
* Sets the stroke for the grid lines plotted against the domain axis and
* sends a {@link PlotChangeEvent} to all registered listeners.
*
* @param stroke the stroke (<code>null not permitted).
*
* @see #getDomainGridlineStroke()
*/
public void setDomainGridlineStroke(Stroke stroke) {
if (stroke == null) {
throw new IllegalArgumentException("Null 'stroke' argument.");
}
this.domainGridlineStroke = stroke;
fireChangeEvent();
}
/**
* Returns the paint for the grid lines (if any) plotted against the domain
* axis.
*
* @return The paint (never <code>null).
*
* @see #setDomainGridlinePaint(Paint)
*/
public Paint getDomainGridlinePaint() {
return this.domainGridlinePaint;
}
/**
* Sets the paint for the grid lines plotted against the domain axis and
* sends a {@link PlotChangeEvent} to all registered listeners.
*
* @param paint the paint (<code>null not permitted).
*
* @see #getDomainGridlinePaint()
*/
public void setDomainGridlinePaint(Paint paint) {
if (paint == null) {
throw new IllegalArgumentException("Null 'paint' argument.");
}
this.domainGridlinePaint = paint;
fireChangeEvent();
}
/**
* Returns <code>true if the range axis grid is visible, and
* <code>false otherwise.
*
* @return <code>true or false.
*
* @see #setRangeGridlinesVisible(boolean)
*/
public boolean isRangeGridlinesVisible() {
return this.rangeGridlinesVisible;
}
/**
* Sets the flag that controls whether or not the range axis grid lines are
* visible. If the flag value is changed, a {@link PlotChangeEvent} is
* sent to all registered listeners.
*
* @param visible the new value of the flag.
*
* @see #isRangeGridlinesVisible()
*/
public void setRangeGridlinesVisible(boolean visible) {
if (this.rangeGridlinesVisible != visible) {
this.rangeGridlinesVisible = visible;
fireChangeEvent();
}
}
/**
* Returns the stroke for the grid lines (if any) plotted against the range
* axis.
*
* @return The stroke (never <code>null).
*
* @see #setRangeGridlineStroke(Stroke)
*/
public Stroke getRangeGridlineStroke() {
return this.rangeGridlineStroke;
}
/**
* Sets the stroke for the grid lines plotted against the range axis and
* sends a {@link PlotChangeEvent} to all registered listeners.
*
* @param stroke the stroke (<code>null permitted).
*
* @see #getRangeGridlineStroke()
*/
public void setRangeGridlineStroke(Stroke stroke) {
if (stroke == null) {
throw new IllegalArgumentException("Null 'stroke' argument.");
}
this.rangeGridlineStroke = stroke;
fireChangeEvent();
}
/**
* Returns the paint for the grid lines (if any) plotted against the range
* axis.
*
* @return The paint (never <code>null).
*
* @see #setRangeGridlinePaint(Paint)
*/
public Paint getRangeGridlinePaint() {
return this.rangeGridlinePaint;
}
/**
* Sets the paint for the grid lines plotted against the range axis and
* sends a {@link PlotChangeEvent} to all registered listeners.
*
* @param paint the paint (<code>null not permitted).
*
* @see #getRangeGridlinePaint()
*/
public void setRangeGridlinePaint(Paint paint) {
if (paint == null) {
throw new IllegalArgumentException("Null 'paint' argument.");
}
this.rangeGridlinePaint = paint;
fireChangeEvent();
}
/**
* Draws the fast scatter plot on a Java 2D graphics device (such as the
* screen or a printer).
*
* @param g2 the graphics device.
* @param area the area within which the plot (including axis labels)
* should be drawn.
* @param anchor the anchor point (<code>null permitted).
* @param parentState the state from the parent plot (ignored).
* @param info collects chart drawing information (<code>null
* permitted).
*/
public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor,
PlotState parentState,
PlotRenderingInfo info) {
// set up info collection...
if (info != null) {
info.setPlotArea(area);
}
// adjust the drawing area for plot insets (if any)...
RectangleInsets insets = getInsets();
insets.trim(area);
AxisSpace space = new AxisSpace();
space = this.domainAxis.reserveSpace(g2, this, area,
RectangleEdge.BOTTOM, space);
space = this.rangeAxis.reserveSpace(g2, this, area, RectangleEdge.LEFT,
space);
Rectangle2D dataArea = space.shrink(area, null);
if (info != null) {
info.setDataArea(dataArea);
}
// draw the plot background and axes...
drawBackground(g2, dataArea);
AxisState domainAxisState = this.domainAxis.draw(g2,
dataArea.getMaxY(), area, dataArea, RectangleEdge.BOTTOM, info);
AxisState rangeAxisState = this.rangeAxis.draw(g2, dataArea.getMinX(),
area, dataArea, RectangleEdge.LEFT, info);
drawDomainGridlines(g2, dataArea, domainAxisState.getTicks());
drawRangeGridlines(g2, dataArea, rangeAxisState.getTicks());
Shape originalClip = g2.getClip();
Composite originalComposite = g2.getComposite();
g2.clip(dataArea);
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
getForegroundAlpha()));
render(g2, dataArea, info, null);
g2.setClip(originalClip);
g2.setComposite(originalComposite);
drawOutline(g2, dataArea);
}
/**
* Draws a representation of the data within the dataArea region. The
* <code>info and crosshairState arguments may be
* <code>null.
*
* @param g2 the graphics device.
* @param dataArea the region in which the data is to be drawn.
* @param info an optional object for collection dimension information.
* @param crosshairState collects crosshair information (<code>null
* permitted).
*/
public void render(Graphics2D g2, Rectangle2D dataArea,
PlotRenderingInfo info, CrosshairState crosshairState) {
//long start = System.currentTimeMillis();
//System.out.println("Start: " + start);
g2.setPaint(this.paint);
// if the axes use a linear scale, you can uncomment the code below and
// switch to the alternative transX/transY calculation inside the loop
// that follows - it is a little bit faster then.
//
// int xx = (int) dataArea.getMinX();
// int ww = (int) dataArea.getWidth();
// int yy = (int) dataArea.getMaxY();
// int hh = (int) dataArea.getHeight();
// double domainMin = this.domainAxis.getLowerBound();
// double domainLength = this.domainAxis.getUpperBound() - domainMin;
// double rangeMin = this.rangeAxis.getLowerBound();
// double rangeLength = this.rangeAxis.getUpperBound() - rangeMin;
if (this.data != null) {
for (int i = 0; i < this.data[0].length; i++) {
float x = this.data[0][i];
float y = this.data[1][i];
//int transX = (int) (xx + ww * (x - domainMin) / domainLength);
//int transY = (int) (yy - hh * (y - rangeMin) / rangeLength);
int transX = (int) this.domainAxis.valueToJava2D(x, dataArea,
RectangleEdge.BOTTOM);
int transY = (int) this.rangeAxis.valueToJava2D(y, dataArea,
RectangleEdge.LEFT);
g2.fillRect(transX, transY, 1, 1);
}
}
//long finish = System.currentTimeMillis();
//System.out.println("Finish: " + finish);
//System.out.println("Time: " + (finish - start));
}
/**
* Draws the gridlines for the plot, if they are visible.
*
* @param g2 the graphics device.
* @param dataArea the data area.
* @param ticks the ticks.
*/
protected void drawDomainGridlines(Graphics2D g2, Rectangle2D dataArea,
List ticks) {
// draw the domain grid lines, if the flag says they're visible...
if (isDomainGridlinesVisible()) {
Iterator iterator = ticks.iterator();
while (iterator.hasNext()) {
ValueTick tick = (ValueTick) iterator.next();
double v = this.domainAxis.valueToJava2D(tick.getValue(),
dataArea, RectangleEdge.BOTTOM);
Line2D line = new Line2D.Double(v, dataArea.getMinY(), v,
dataArea.getMaxY());
g2.setPaint(getDomainGridlinePaint());
g2.setStroke(getDomainGridlineStroke());
g2.draw(line);
}
}
}
/**
* Draws the gridlines for the plot, if they are visible.
*
* @param g2 the graphics device.
* @param dataArea the data area.
* @param ticks the ticks.
*/
protected void drawRangeGridlines(Graphics2D g2, Rectangle2D dataArea,
List ticks) {
// draw the range grid lines, if the flag says they're visible...
if (isRangeGridlinesVisible()) {
Iterator iterator = ticks.iterator();
while (iterator.hasNext()) {
ValueTick tick = (ValueTick) iterator.next();
double v = this.rangeAxis.valueToJava2D(tick.getValue(),
dataArea, RectangleEdge.LEFT);
Line2D line = new Line2D.Double(dataArea.getMinX(), v,
dataArea.getMaxX(), v);
g2.setPaint(getRangeGridlinePaint());
g2.setStroke(getRangeGridlineStroke());
g2.draw(line);
}
}
}
/**
* Returns the range of data values to be plotted along the axis, or
* <code>null if the specified axis isn't the domain axis or the
* range axis for the plot.
*
* @param axis the axis (<code>null permitted).
*
* @return The range (possibly <code>null).
*/
public Range getDataRange(ValueAxis axis) {
Range result = null;
if (axis == this.domainAxis) {
result = this.xDataRange;
}
else if (axis == this.rangeAxis) {
result = this.yDataRange;
}
return result;
}
/**
* Calculates the X data range.
*
* @param data the data (<code>null permitted).
*
* @return The range.
*/
private Range calculateXDataRange(float[][] data) {
Range result = null;
if (data != null) {
float lowest = Float.POSITIVE_INFINITY;
float highest = Float.NEGATIVE_INFINITY;
for (int i = 0; i < data[0].length; i++) {
float v = data[0][i];
if (v < lowest) {
lowest = v;
}
if (v > highest) {
highest = v;
}
}
if (lowest <= highest) {
result = new Range(lowest, highest);
}
}
return result;
}
/**
* Calculates the Y data range.
*
* @param data the data (<code>null permitted).
*
* @return The range.
*/
private Range calculateYDataRange(float[][] data) {
Range result = null;
if (data != null) {
float lowest = Float.POSITIVE_INFINITY;
float highest = Float.NEGATIVE_INFINITY;
for (int i = 0; i < data[0].length; i++) {
float v = data[1][i];
if (v < lowest) {
lowest = v;
}
if (v > highest) {
highest = v;
}
}
if (lowest <= highest) {
result = new Range(lowest, highest);
}
}
return result;
}
/**
* Multiplies the range on the domain axis by the specified factor.
*
* @param factor the zoom factor.
* @param info the plot rendering info.
* @param source the source point.
*/
public void zoomDomainAxes(double factor, PlotRenderingInfo info,
Point2D source) {
this.domainAxis.resizeRange(factor);
}
/**
* Multiplies the range on the domain axis by the specified factor.
*
* @param factor the zoom factor.
* @param info the plot rendering info.
* @param source the source point (in Java2D space).
* @param useAnchor use source point as zoom anchor?
*
* @see #zoomRangeAxes(double, PlotRenderingInfo, Point2D, boolean)
*
* @since 1.0.7
*/
public void zoomDomainAxes(double factor, PlotRenderingInfo info,
Point2D source, boolean useAnchor) {
if (useAnchor) {
// get the source coordinate - this plot has always a VERTICAL
// orientation
double sourceX = source.getX();
double anchorX = this.domainAxis.java2DToValue(sourceX,
info.getDataArea(), RectangleEdge.BOTTOM);
this.domainAxis.resizeRange2(factor, anchorX);
}
else {
this.domainAxis.resizeRange(factor);
}
}
/**
* Zooms in on the domain axes.
*
* @param lowerPercent the new lower bound as a percentage of the current
* range.
* @param upperPercent the new upper bound as a percentage of the current
* range.
* @param info the plot rendering info.
* @param source the source point.
*/
public void zoomDomainAxes(double lowerPercent, double upperPercent,
PlotRenderingInfo info, Point2D source) {
this.domainAxis.zoomRange(lowerPercent, upperPercent);
}
/**
* Multiplies the range on the range axis/axes by the specified factor.
*
* @param factor the zoom factor.
* @param info the plot rendering info.
* @param source the source point.
*/
public void zoomRangeAxes(double factor,
PlotRenderingInfo info, Point2D source) {
this.rangeAxis.resizeRange(factor);
}
/**
* Multiplies the range on the range axis by the specified factor.
*
* @param factor the zoom factor.
* @param info the plot rendering info.
* @param source the source point (in Java2D space).
* @param useAnchor use source point as zoom anchor?
*
* @see #zoomDomainAxes(double, PlotRenderingInfo, Point2D, boolean)
*
* @since 1.0.7
*/
public void zoomRangeAxes(double factor, PlotRenderingInfo info,
Point2D source, boolean useAnchor) {
if (useAnchor) {
// get the source coordinate - this plot has always a VERTICAL
// orientation
double sourceY = source.getY();
double anchorY = this.rangeAxis.java2DToValue(sourceY,
info.getDataArea(), RectangleEdge.LEFT);
this.rangeAxis.resizeRange2(factor, anchorY);
}
else {
this.rangeAxis.resizeRange(factor);
}
}
/**
* Zooms in on the range axes.
*
* @param lowerPercent the new lower bound as a percentage of the current
* range.
* @param upperPercent the new upper bound as a percentage of the current
* range.
* @param info the plot rendering info.
* @param source the source point.
*/
public void zoomRangeAxes(double lowerPercent, double upperPercent,
PlotRenderingInfo info, Point2D source) {
this.rangeAxis.zoomRange(lowerPercent, upperPercent);
}
/**
* Returns <code>true.
*
* @return A boolean.
*/
public boolean isDomainZoomable() {
return true;
}
/**
* Returns <code>true.
*
* @return A boolean.
*/
public boolean isRangeZoomable() {
return true;
}
/**
* Returns <code>true if panning is enabled for the domain axes,
* and <code>false otherwise.
*
* @return A boolean.
*
* @since 1.0.13
*/
public boolean isDomainPannable() {
return this.domainPannable;
}
/**
* Sets the flag that enables or disables panning of the plot along the
* domain axes.
*
* @param pannable the new flag value.
*
* @since 1.0.13
*/
public void setDomainPannable(boolean pannable) {
this.domainPannable = pannable;
}
/**
* Returns <code>true if panning is enabled for the range axes,
* and <code>false otherwise.
*
* @return A boolean.
*
* @since 1.0.13
*/
public boolean isRangePannable() {
return this.rangePannable;
}
/**
* Sets the flag that enables or disables panning of the plot along
* the range axes.
*
* @param pannable the new flag value.
*
* @since 1.0.13
*/
public void setRangePannable(boolean pannable) {
this.rangePannable = pannable;
}
/**
* Pans the domain axes by the specified percentage.
*
* @param percent the distance to pan (as a percentage of the axis length).
* @param info the plot info
* @param source the source point where the pan action started.
*
* @since 1.0.13
*/
public void panDomainAxes(double percent, PlotRenderingInfo info,
Point2D source) {
if (!isDomainPannable() || this.domainAxis == null) {
return;
}
double length = this.domainAxis.getRange().getLength();
double adj = -percent * length;
if (this.domainAxis.isInverted()) {
adj = -adj;
}
this.domainAxis.setRange(this.domainAxis.getLowerBound() + adj,
this.domainAxis.getUpperBound() + adj);
}
/**
* Pans the range axes by the specified percentage.
*
* @param percent the distance to pan (as a percentage of the axis length).
* @param info the plot info
* @param source the source point where the pan action started.
*
* @since 1.0.13
*/
public void panRangeAxes(double percent, PlotRenderingInfo info,
Point2D source) {
if (!isRangePannable() || this.rangeAxis == null) {
return;
}
double length = this.rangeAxis.getRange().getLength();
double adj = percent * length;
if (this.rangeAxis.isInverted()) {
adj = -adj;
}
this.rangeAxis.setRange(this.rangeAxis.getLowerBound() + adj,
this.rangeAxis.getUpperBound() + adj);
}
/**
* Tests an arbitrary object for equality with this plot. Note that
* <code>FastScatterPlot carries its data around with it (rather
* than referencing a dataset), and the data is included in the
* equality test.
*
* @param obj the object (<code>null permitted).
*
* @return A boolean.
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (!(obj instanceof FastScatterPlot)) {
return false;
}
FastScatterPlot that = (FastScatterPlot) obj;
if (this.domainPannable != that.domainPannable) {
return false;
}
if (this.rangePannable != that.rangePannable) {
return false;
}
if (!ArrayUtilities.equal(this.data, that.data)) {
return false;
}
if (!ObjectUtilities.equal(this.domainAxis, that.domainAxis)) {
return false;
}
if (!ObjectUtilities.equal(this.rangeAxis, that.rangeAxis)) {
return false;
}
if (!PaintUtilities.equal(this.paint, that.paint)) {
return false;
}
if (this.domainGridlinesVisible != that.domainGridlinesVisible) {
return false;
}
if (!PaintUtilities.equal(this.domainGridlinePaint,
that.domainGridlinePaint)) {
return false;
}
if (!ObjectUtilities.equal(this.domainGridlineStroke,
that.domainGridlineStroke)) {
return false;
}
if (!this.rangeGridlinesVisible == that.rangeGridlinesVisible) {
return false;
}
if (!PaintUtilities.equal(this.rangeGridlinePaint,
that.rangeGridlinePaint)) {
return false;
}
if (!ObjectUtilities.equal(this.rangeGridlineStroke,
that.rangeGridlineStroke)) {
return false;
}
return true;
}
/**
* Returns a clone of the plot.
*
* @return A clone.
*
* @throws CloneNotSupportedException if some component of the plot does
* not support cloning.
*/
public Object clone() throws CloneNotSupportedException {
FastScatterPlot clone = (FastScatterPlot) super.clone();
if (this.data != null) {
clone.data = ArrayUtilities.clone(this.data);
}
if (this.domainAxis != null) {
clone.domainAxis = (ValueAxis) this.domainAxis.clone();
clone.domainAxis.setPlot(clone);
clone.domainAxis.addChangeListener(clone);
}
if (this.rangeAxis != null) {
clone.rangeAxis = (ValueAxis) this.rangeAxis.clone();
clone.rangeAxis.setPlot(clone);
clone.rangeAxis.addChangeListener(clone);
}
return clone;
}
/**
* Provides serialization support.
*
* @param stream the output stream.
*
* @throws IOException if there is an I/O error.
*/
private void writeObject(ObjectOutputStream stream) throws IOException {
stream.defaultWriteObject();
SerialUtilities.writePaint(this.paint, stream);
SerialUtilities.writeStroke(this.domainGridlineStroke, stream);
SerialUtilities.writePaint(this.domainGridlinePaint, stream);
SerialUtilities.writeStroke(this.rangeGridlineStroke, stream);
SerialUtilities.writePaint(this.rangeGridlinePaint, stream);
}
/**
* Provides serialization support.
*
* @param stream the input stream.
*
* @throws IOException if there is an I/O error.
* @throws ClassNotFoundException if there is a classpath problem.
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
stream.defaultReadObject();
this.paint = SerialUtilities.readPaint(stream);
this.domainGridlineStroke = SerialUtilities.readStroke(stream);
this.domainGridlinePaint = SerialUtilities.readPaint(stream);
this.rangeGridlineStroke = SerialUtilities.readStroke(stream);
this.rangeGridlinePaint = SerialUtilities.readPaint(stream);
if (this.domainAxis != null) {
this.domainAxis.addChangeListener(this);
}
if (this.rangeAxis != null) {
this.rangeAxis.addChangeListener(this);
}
}
}
Other jfreechart examples (source code examples)
Here is a short list of links related to this jfreechart FastScatterPlot.java source code file:
|
The search page
Other jfreechart source code examples at this package level
Click here to learn more about this project
