org.jfree.chart.axis.LogAxis Maven / Gradle / Ivy
Show all versions of jfreechart Show documentation
/* ===========================================================
* JFreeChart : a free chart library for the Java(tm) platform
* ===========================================================
*
* (C) Copyright 2000-2007, 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.]
*
* ------------
* LogAxis.java
* ------------
* (C) Copyright 2006, 2007, by Object Refinery Limited and Contributors.
*
* Original Author: David Gilbert (for Object Refinery Limited);
* Contributor(s): -;
*
* Changes
* -------
* 24-Aug-2006 : Version 1 (DG);
* 22-Mar-2007 : Use defaultAutoArrange attribute (DG);
* 02-Aug-2007 : Fixed zooming bug, added support for margins (DG);
*
*/
package org.jfree.chart.axis;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.font.FontRenderContext;
import java.awt.font.LineMetrics;
import java.awt.geom.Rectangle2D;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.jfree.chart.event.AxisChangeEvent;
import org.jfree.chart.plot.Plot;
import org.jfree.chart.plot.PlotRenderingInfo;
import org.jfree.chart.plot.ValueAxisPlot;
import org.jfree.data.Range;
import org.jfree.ui.RectangleEdge;
import org.jfree.ui.RectangleInsets;
import org.jfree.ui.TextAnchor;
/**
* A numerical axis that uses a logarithmic scale. The class is an
* alternative to the {@link LogarithmicAxis} class.
*
* @since 1.0.7
*/
public class LogAxis extends ValueAxis {
/** The logarithm base. */
private double base = 10.0;
/** The logarithm of the base value - cached for performance. */
private double baseLog = Math.log(10.0);
/** The smallest value permitted on the axis. */
private double smallestValue = 1E-100;
/** The current tick unit. */
private NumberTickUnit tickUnit;
/** The override number format. */
private NumberFormat numberFormatOverride;
/** The number of minor ticks per major tick unit. */
private int minorTickCount;
/**
* Creates a new LogAxis with no label.
*/
public LogAxis() {
this(null);
}
/**
* Creates a new LogAxis with the given label.
*
* @param label the axis label (null permitted).
*/
public LogAxis(String label) {
super(label, createLogTickUnits(Locale.getDefault()));
setDefaultAutoRange(new Range(0.01, 1.0));
this.tickUnit = new NumberTickUnit(1.0, new DecimalFormat("0.#"));
this.minorTickCount = 10;
}
/**
* Returns the base for the logarithm calculation.
*
* @return The base for the logarithm calculation.
*
* @see #setBase(double)
*/
public double getBase() {
return this.base;
}
/**
* Sets the base for the logarithm calculation and sends an
* {@link AxisChangeEvent} to all registered listeners.
*
* @param base the base value (must be > 1.0).
*
* @see #getBase()
*/
public void setBase(double base) {
if (base <= 1.0) {
throw new IllegalArgumentException("Requires 'base' > 1.0.");
}
this.base = base;
this.baseLog = Math.log(base);
notifyListeners(new AxisChangeEvent(this));
}
/**
* Returns the smallest value represented by the axis.
*
* @return The smallest value represented by the axis.
*
* @see #setSmallestValue(double)
*/
public double getSmallestValue() {
return this.smallestValue;
}
/**
* Sets the smallest value represented by the axis and sends an
* {@link AxisChangeEvent} to all registered listeners.
*
* @param value the value.
*
* @see #getSmallestValue()
*/
public void setSmallestValue(double value) {
if (value <= 0.0) {
throw new IllegalArgumentException("Requires 'value' > 0.0.");
}
this.smallestValue = value;
notifyListeners(new AxisChangeEvent(this));
}
/**
* Returns the current tick unit.
*
* @return The current tick unit.
*
* @see #setTickUnit(NumberTickUnit)
*/
public NumberTickUnit getTickUnit() {
return this.tickUnit;
}
/**
* Sets the tick unit for the axis and sends an {@link AxisChangeEvent} to
* all registered listeners. A side effect of calling this method is that
* the "auto-select" feature for tick units is switched off (you can
* restore it using the {@link ValueAxis#setAutoTickUnitSelection(boolean)}
* method).
*
* @param unit the new tick unit (null not permitted).
*
* @see #getTickUnit()
*/
public void setTickUnit(NumberTickUnit unit) {
// defer argument checking...
setTickUnit(unit, true, true);
}
/**
* Sets the tick unit for the axis and, if requested, sends an
* {@link AxisChangeEvent} to all registered listeners. In addition, an
* option is provided to turn off the "auto-select" feature for tick units
* (you can restore it using the
* {@link ValueAxis#setAutoTickUnitSelection(boolean)} method).
*
* @param unit the new tick unit (null not permitted).
* @param notify notify listeners?
* @param turnOffAutoSelect turn off the auto-tick selection?
*
* @see #getTickUnit()
*/
public void setTickUnit(NumberTickUnit unit, boolean notify,
boolean turnOffAutoSelect) {
if (unit == null) {
throw new IllegalArgumentException("Null 'unit' argument.");
}
this.tickUnit = unit;
if (turnOffAutoSelect) {
setAutoTickUnitSelection(false, false);
}
if (notify) {
notifyListeners(new AxisChangeEvent(this));
}
}
/**
* Returns the number format override. If this is non-null, then it will
* be used to format the numbers on the axis.
*
* @return The number formatter (possibly null).
*
* @see #setNumberFormatOverride(NumberFormat)
*/
public NumberFormat getNumberFormatOverride() {
return this.numberFormatOverride;
}
/**
* Sets the number format override. If this is non-null, then it will be
* used to format the numbers on the axis.
*
* @param formatter the number formatter (null permitted).
*
* @see #getNumberFormatOverride()
*/
public void setNumberFormatOverride(NumberFormat formatter) {
this.numberFormatOverride = formatter;
notifyListeners(new AxisChangeEvent(this));
}
/**
* Returns the number of minor tick marks to display.
*
* @return The number of minor tick marks to display.
*
* @see #setMinorTickCount(int)
*/
public int getMinorTickCount() {
return this.minorTickCount;
}
/**
* Sets the number of minor tick marks to display, and sends an
* {@link AxisChangeEvent} to all registered listeners.
*
* @param count the count.
*
* @see #getMinorTickCount()
*/
public void setMinorTickCount(int count) {
if (count <= 0) {
throw new IllegalArgumentException("Requires 'count' > 0.");
}
this.minorTickCount = count;
notifyListeners(new AxisChangeEvent(this));
}
/**
* Calculates the log of the given value, using the current base.
*
* @param value the value.
*
* @return The log of the given value.
*
* @see #calculateValue(double)
* @see #getBase()
*/
public double calculateLog(double value) {
return Math.log(value) / this.baseLog;
}
/**
* Calculates the value from a given log.
*
* @param log the log value (must be > 0.0).
*
* @return The value with the given log.
*
* @see #calculateLog(double)
* @see #getBase()
*/
public double calculateValue(double log) {
return Math.pow(this.base, log);
}
/**
* Converts a Java2D coordinate to an axis value, assuming that the
* axis covers the specified edge of the area.
*
* @param java2DValue the Java2D coordinate.
* @param area the area.
* @param edge the edge that the axis belongs to.
*
* @return A value along the axis scale.
*/
public double java2DToValue(double java2DValue, Rectangle2D area,
RectangleEdge edge) {
Range range = getRange();
double axisMin = calculateLog(range.getLowerBound());
double axisMax = calculateLog(range.getUpperBound());
double min = 0.0;
double max = 0.0;
if (RectangleEdge.isTopOrBottom(edge)) {
min = area.getX();
max = area.getMaxX();
}
else if (RectangleEdge.isLeftOrRight(edge)) {
min = area.getMaxY();
max = area.getY();
}
double log = 0.0;
if (isInverted()) {
log = axisMax - (java2DValue - min) / (max - min)
* (axisMax - axisMin);
}
else {
log = axisMin + (java2DValue - min) / (max - min)
* (axisMax - axisMin);
}
return calculateValue(log);
}
/**
* Converts a value on the axis scale to a Java2D coordinate relative to
* the given area, based on the axis running along the
* specified edge.
*
* @param value the data value.
* @param area the area.
* @param edge the edge.
*
* @return The Java2D coordinate corresponding to value.
*/
public double valueToJava2D(double value, Rectangle2D area,
RectangleEdge edge) {
Range range = getRange();
double axisMin = calculateLog(range.getLowerBound());
double axisMax = calculateLog(range.getUpperBound());
value = calculateLog(value);
double min = 0.0;
double max = 0.0;
if (RectangleEdge.isTopOrBottom(edge)) {
min = area.getX();
max = area.getMaxX();
}
else if (RectangleEdge.isLeftOrRight(edge)) {
max = area.getMinY();
min = area.getMaxY();
}
if (isInverted()) {
return max
- ((value - axisMin) / (axisMax - axisMin)) * (max - min);
}
else {
return min
+ ((value - axisMin) / (axisMax - axisMin)) * (max - min);
}
}
/**
* Configures the axis. This method is typically called when an axis
* is assigned to a new plot.
*/
public void configure() {
if (isAutoRange()) {
autoAdjustRange();
}
}
/**
* Adjusts the axis range to match the data range that the axis is
* required to display.
*/
protected void autoAdjustRange() {
Plot plot = getPlot();
if (plot == null) {
return; // no plot, no data
}
if (plot instanceof ValueAxisPlot) {
ValueAxisPlot vap = (ValueAxisPlot) plot;
Range r = vap.getDataRange(this);
if (r == null) {
r = getDefaultAutoRange();
}
double upper = r.getUpperBound();
double lower = Math.max(r.getLowerBound(), this.smallestValue);
double range = upper - lower;
// if fixed auto range, then derive lower bound...
double fixedAutoRange = getFixedAutoRange();
if (fixedAutoRange > 0.0) {
lower = Math.max(upper - fixedAutoRange, this.smallestValue);
}
else {
// ensure the autorange is at least in size...
double minRange = getAutoRangeMinimumSize();
if (range < minRange) {
double expand = (minRange - range) / 2;
upper = upper + expand;
lower = lower - expand;
}
// apply the margins - these should apply to the exponent range
double logUpper = calculateLog(upper);
double logLower = calculateLog(lower);
double logRange = logUpper - logLower;
logUpper = logUpper + getUpperMargin() * logRange;
logLower = logLower - getLowerMargin() * logRange;
upper = calculateValue(logUpper);
lower = calculateValue(logLower);
}
setRange(new Range(lower, upper), false, false);
}
}
/**
* Draws the axis on a Java 2D graphics device (such as the screen or a
* printer).
*
* @param g2 the graphics device (null not permitted).
* @param cursor the cursor location (determines where to draw the axis).
* @param plotArea the area within which the axes and plot should be drawn.
* @param dataArea the area within which the data should be drawn.
* @param edge the axis location (null not permitted).
* @param plotState collects information about the plot
* (null permitted).
*
* @return The axis state (never null).
*/
public AxisState draw(Graphics2D g2, double cursor, Rectangle2D plotArea,
Rectangle2D dataArea, RectangleEdge edge,
PlotRenderingInfo plotState) {
AxisState state = null;
// if the axis is not visible, don't draw it...
if (!isVisible()) {
state = new AxisState(cursor);
// even though the axis is not visible, we need ticks for the
// gridlines...
List ticks = refreshTicks(g2, state, dataArea, edge);
state.setTicks(ticks);
return state;
}
state = drawTickMarksAndLabels(g2, cursor, plotArea, dataArea, edge);
state = drawLabel(getLabel(), g2, plotArea, dataArea, edge, state);
return state;
}
/**
* Calculates the positions of the tick labels for the axis, storing the
* results in the tick label list (ready for drawing).
*
* @param g2 the graphics device.
* @param state the axis state.
* @param dataArea the area in which the plot should be drawn.
* @param edge the location of the axis.
*
* @return A list of ticks.
*
*/
public List refreshTicks(Graphics2D g2, AxisState state,
Rectangle2D dataArea, RectangleEdge edge) {
List result = new java.util.ArrayList();
if (RectangleEdge.isTopOrBottom(edge)) {
result = refreshTicksHorizontal(g2, dataArea, edge);
}
else if (RectangleEdge.isLeftOrRight(edge)) {
result = refreshTicksVertical(g2, dataArea, edge);
}
return result;
}
/**
* Returns a list of ticks for an axis at the top or bottom of the chart.
*
* @param g2 the graphics device.
* @param dataArea the data area.
* @param edge the edge.
*
* @return A list of ticks.
*/
protected List refreshTicksHorizontal(Graphics2D g2, Rectangle2D dataArea,
RectangleEdge edge) {
Range range = getRange();
List ticks = new ArrayList();
Font tickLabelFont = getTickLabelFont();
g2.setFont(tickLabelFont);
if (isAutoTickUnitSelection()) {
selectAutoTickUnit(g2, dataArea, edge);
}
double start = Math.floor(calculateLog(getLowerBound()));
double end = Math.ceil(calculateLog(getUpperBound()));
double current = start;
while (current <= end) {
double v = calculateValue(current);
if (range.contains(v)) {
ticks.add(new NumberTick(TickType.MAJOR, v, createTickLabel(v),
TextAnchor.TOP_CENTER, TextAnchor.CENTER, 0.0));
}
// add minor ticks (for gridlines)
double next = Math.pow(this.base, current
+ this.tickUnit.getSize());
for (int i = 1; i < this.minorTickCount; i++) {
double minorV = v + i * ((next - v) / this.minorTickCount);
if (range.contains(minorV)) {
ticks.add(new NumberTick(TickType.MINOR, minorV,
"", TextAnchor.TOP_CENTER, TextAnchor.CENTER, 0.0));
}
}
current = current + this.tickUnit.getSize();
}
return ticks;
}
/**
* Returns a list of ticks for an axis at the left or right of the chart.
*
* @param g2 the graphics device.
* @param dataArea the data area.
* @param edge the edge.
*
* @return A list of ticks.
*/
protected List refreshTicksVertical(Graphics2D g2, Rectangle2D dataArea,
RectangleEdge edge) {
Range range = getRange();
List ticks = new ArrayList();
Font tickLabelFont = getTickLabelFont();
g2.setFont(tickLabelFont);
if (isAutoTickUnitSelection()) {
selectAutoTickUnit(g2, dataArea, edge);
}
double start = Math.floor(calculateLog(getLowerBound()));
double end = Math.ceil(calculateLog(getUpperBound()));
double current = start;
while (current <= end) {
double v = calculateValue(current);
if (range.contains(v)) {
ticks.add(new NumberTick(TickType.MINOR, v, createTickLabel(v),
TextAnchor.CENTER_RIGHT, TextAnchor.CENTER, 0.0));
}
// add minor ticks (for gridlines)
double next = Math.pow(this.base, current
+ this.tickUnit.getSize());
for (int i = 1; i < this.minorTickCount; i++) {
double minorV = v + i * ((next - v) / this.minorTickCount);
if (range.contains(minorV)) {
ticks.add(new NumberTick(TickType.MINOR, minorV, "",
TextAnchor.CENTER_RIGHT, TextAnchor.CENTER, 0.0));
}
}
current = current + this.tickUnit.getSize();
}
return ticks;
}
/**
* Selects an appropriate tick value for the axis. The strategy is to
* display as many ticks as possible (selected from an array of 'standard'
* tick units) without the labels overlapping.
*
* @param g2 the graphics device.
* @param dataArea the area defined by the axes.
* @param edge the axis location.
*
* @since 1.0.7
*/
protected void selectAutoTickUnit(Graphics2D g2, Rectangle2D dataArea,
RectangleEdge edge) {
if (RectangleEdge.isTopOrBottom(edge)) {
selectHorizontalAutoTickUnit(g2, dataArea, edge);
}
else if (RectangleEdge.isLeftOrRight(edge)) {
selectVerticalAutoTickUnit(g2, dataArea, edge);
}
}
/**
* Selects an appropriate tick value for the axis. The strategy is to
* display as many ticks as possible (selected from an array of 'standard'
* tick units) without the labels overlapping.
*
* @param g2 the graphics device.
* @param dataArea the area defined by the axes.
* @param edge the axis location.
*
* @since 1.0.7
*/
protected void selectHorizontalAutoTickUnit(Graphics2D g2,
Rectangle2D dataArea, RectangleEdge edge) {
double tickLabelWidth = estimateMaximumTickLabelWidth(g2,
getTickUnit());
// start with the current tick unit...
TickUnitSource tickUnits = getStandardTickUnits();
TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
double unit1Width = exponentLengthToJava2D(unit1.getSize(), dataArea,
edge);
// then extrapolate...
double guess = (tickLabelWidth / unit1Width) * unit1.getSize();
NumberTickUnit unit2 = (NumberTickUnit)
tickUnits.getCeilingTickUnit(guess);
double unit2Width = exponentLengthToJava2D(unit2.getSize(), dataArea,
edge);
tickLabelWidth = estimateMaximumTickLabelWidth(g2, unit2);
if (tickLabelWidth > unit2Width) {
unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
}
setTickUnit(unit2, false, false);
}
/**
* Converts a length in data coordinates into the corresponding length in
* Java2D coordinates.
*
* @param length the length.
* @param area the plot area.
* @param edge the edge along which the axis lies.
*
* @return The length in Java2D coordinates.
*
* @since 1.0.7
*/
public double exponentLengthToJava2D(double length, Rectangle2D area,
RectangleEdge edge) {
double one = valueToJava2D(calculateValue(1.0), area, edge);
double l = valueToJava2D(calculateValue(length + 1.0), area, edge);
return Math.abs(l - one);
}
/**
* Selects an appropriate tick value for the axis. The strategy is to
* display as many ticks as possible (selected from an array of 'standard'
* tick units) without the labels overlapping.
*
* @param g2 the graphics device.
* @param dataArea the area in which the plot should be drawn.
* @param edge the axis location.
*
* @since 1.0.7
*/
protected void selectVerticalAutoTickUnit(Graphics2D g2,
Rectangle2D dataArea,
RectangleEdge edge) {
double tickLabelHeight = estimateMaximumTickLabelHeight(g2);
// start with the current tick unit...
TickUnitSource tickUnits = getStandardTickUnits();
TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
double unitHeight = exponentLengthToJava2D(unit1.getSize(), dataArea,
edge);
// then extrapolate...
double guess = (tickLabelHeight / unitHeight) * unit1.getSize();
NumberTickUnit unit2 = (NumberTickUnit)
tickUnits.getCeilingTickUnit(guess);
double unit2Height = exponentLengthToJava2D(unit2.getSize(), dataArea,
edge);
tickLabelHeight = estimateMaximumTickLabelHeight(g2);
if (tickLabelHeight > unit2Height) {
unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
}
setTickUnit(unit2, false, false);
}
/**
* Estimates the maximum tick label height.
*
* @param g2 the graphics device.
*
* @return The maximum height.
*
* @since 1.0.7
*/
protected double estimateMaximumTickLabelHeight(Graphics2D g2) {
RectangleInsets tickLabelInsets = getTickLabelInsets();
double result = tickLabelInsets.getTop() + tickLabelInsets.getBottom();
Font tickLabelFont = getTickLabelFont();
FontRenderContext frc = g2.getFontRenderContext();
result += tickLabelFont.getLineMetrics("123", frc).getHeight();
return result;
}
/**
* Estimates the maximum width of the tick labels, assuming the specified
* tick unit is used.
*
* Rather than computing the string bounds of every tick on the axis, we
* just look at two values: the lower bound and the upper bound for the
* axis. These two values will usually be representative.
*
* @param g2 the graphics device.
* @param unit the tick unit to use for calculation.
*
* @return The estimated maximum width of the tick labels.
*
* @since 1.0.7
*/
protected double estimateMaximumTickLabelWidth(Graphics2D g2,
TickUnit unit) {
RectangleInsets tickLabelInsets = getTickLabelInsets();
double result = tickLabelInsets.getLeft() + tickLabelInsets.getRight();
if (isVerticalTickLabels()) {
// all tick labels have the same width (equal to the height of the
// font)...
FontRenderContext frc = g2.getFontRenderContext();
LineMetrics lm = getTickLabelFont().getLineMetrics("0", frc);
result += lm.getHeight();
}
else {
// look at lower and upper bounds...
FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
Range range = getRange();
double lower = range.getLowerBound();
double upper = range.getUpperBound();
String lowerStr = "";
String upperStr = "";
NumberFormat formatter = getNumberFormatOverride();
if (formatter != null) {
lowerStr = formatter.format(lower);
upperStr = formatter.format(upper);
}
else {
lowerStr = unit.valueToString(lower);
upperStr = unit.valueToString(upper);
}
double w1 = fm.stringWidth(lowerStr);
double w2 = fm.stringWidth(upperStr);
result += Math.max(w1, w2);
}
return result;
}
/**
* Zooms in on the current range.
*
* @param lowerPercent the new lower bound.
* @param upperPercent the new upper bound.
*/
public void zoomRange(double lowerPercent, double upperPercent) {
Range range = getRange();
double start = range.getLowerBound();
double end = range.getUpperBound();
double log1 = calculateLog(start);
double log2 = calculateLog(end);
double length = log2 - log1;
Range adjusted = null;
if (isInverted()) {
double logA = log1 + length * (1 - upperPercent);
double logB = log1 + length * (1 - lowerPercent);
adjusted = new Range(calculateValue(logA), calculateValue(logB));
}
else {
double logA = log1 + length * lowerPercent;
double logB = log1 + length * upperPercent;
adjusted = new Range(calculateValue(logA), calculateValue(logB));
}
setRange(adjusted);
}
/**
* Creates a tick label for the specified value.
*
* @param value the value.
*
* @return The label.
*/
private String createTickLabel(double value) {
if (this.numberFormatOverride != null) {
return this.numberFormatOverride.format(value);
}
else {
return this.tickUnit.valueToString(value);
}
}
/**
* Tests this axis for equality with an arbitrary object.
*
* @param obj the object (null permitted).
*
* @return A boolean.
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof LogAxis)) {
return false;
}
LogAxis that = (LogAxis) obj;
if (this.base != that.base) {
return false;
}
if (this.smallestValue != that.smallestValue) {
return false;
}
if (this.minorTickCount != that.minorTickCount) {
return false;
}
return super.equals(obj);
}
/**
* Returns a hash code for this instance.
*
* @return A hash code.
*/
public int hashCode() {
int result = 193;
long temp = Double.doubleToLongBits(this.base);
result = 37 * result + (int) (temp ^ (temp >>> 32));
result = 37 * result + this.minorTickCount;
temp = Double.doubleToLongBits(this.smallestValue);
result = 37 * result + (int) (temp ^ (temp >>> 32));
if (this.numberFormatOverride != null) {
result = 37 * result + this.numberFormatOverride.hashCode();
}
result = 37 * result + this.tickUnit.hashCode();
return result;
}
/**
* Returns a collection of tick units for log (base 10) values.
* Uses a given Locale to create the DecimalFormats.
*
* @param locale the locale to use to represent Numbers.
*
* @return A collection of tick units for integer values.
*
* @since 1.0.7
*/
public static TickUnitSource createLogTickUnits(Locale locale) {
TickUnits units = new TickUnits();
NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);
units.add(new NumberTickUnit(1, numberFormat));
units.add(new NumberTickUnit(2, numberFormat));
units.add(new NumberTickUnit(5, numberFormat));
units.add(new NumberTickUnit(10, numberFormat));
units.add(new NumberTickUnit(20, numberFormat));
units.add(new NumberTickUnit(50, numberFormat));
units.add(new NumberTickUnit(100, numberFormat));
units.add(new NumberTickUnit(200, numberFormat));
units.add(new NumberTickUnit(500, numberFormat));
units.add(new NumberTickUnit(1000, numberFormat));
units.add(new NumberTickUnit(2000, numberFormat));
units.add(new NumberTickUnit(5000, numberFormat));
units.add(new NumberTickUnit(10000, numberFormat));
units.add(new NumberTickUnit(20000, numberFormat));
units.add(new NumberTickUnit(50000, numberFormat));
units.add(new NumberTickUnit(100000, numberFormat));
units.add(new NumberTickUnit(200000, numberFormat));
units.add(new NumberTickUnit(500000, numberFormat));
units.add(new NumberTickUnit(1000000, numberFormat));
units.add(new NumberTickUnit(2000000, numberFormat));
units.add(new NumberTickUnit(5000000, numberFormat));
units.add(new NumberTickUnit(10000000, numberFormat));
units.add(new NumberTickUnit(20000000, numberFormat));
units.add(new NumberTickUnit(50000000, numberFormat));
units.add(new NumberTickUnit(100000000, numberFormat));
units.add(new NumberTickUnit(200000000, numberFormat));
units.add(new NumberTickUnit(500000000, numberFormat));
units.add(new NumberTickUnit(1000000000, numberFormat));
units.add(new NumberTickUnit(2000000000, numberFormat));
units.add(new NumberTickUnit(5000000000.0, numberFormat));
units.add(new NumberTickUnit(10000000000.0, numberFormat));
return units;
}
}