    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2007, by Object Refinery Limited and Contributors.
    006     *
    007     * Project Info:  http://www.jfree.org/jfreechart/index.html
    008     *
    009     * This library is free software; you can redistribute it and/or modify it
    010     * under the terms of the GNU Lesser General Public License as published by
    011     * the Free Software Foundation; either version 2.1 of the License, or
    012     * (at your option) any later version.
    013     *
    014     * This library is distributed in the hope that it will be useful, but
    015     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    016     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
    017     * License for more details.
    018     *
    019     * You should have received a copy of the GNU Lesser General Public
    020     * License along with this library; if not, write to the Free Software
    021     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
    022     * USA.
    023     *
    024     * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
    025     * in the United States and other countries.]
    026     *
    027     * ------------
    028     * LogAxis.java
    029     * ------------
    030     * (C) Copyright 2006, 2007, by Object Refinery Limited and Contributors.
    031     *
    032     * Original Author:  David Gilbert (for Object Refinery Limited);
    033     * Contributor(s):   -;
    034     *
    035     * Changes
    036     * -------
    037     * 24-Aug-2006 : Version 1 (DG);
    038     * 22-Mar-2007 : Use defaultAutoArrange attribute (DG);
    039     * 02-Aug-2007 : Fixed zooming bug, added support for margins (DG);
    040     *
    041     */
    042
    043    package org.jfree.chart.axis;
    044
    045    import java.awt.Font;
    046    import java.awt.FontMetrics;
    047    import java.awt.Graphics2D;
    048    import java.awt.font.FontRenderContext;
    049    import java.awt.font.LineMetrics;
    050    import java.awt.geom.Rectangle2D;
    051    import java.text.DecimalFormat;
    052    import java.text.NumberFormat;
    053    import java.util.ArrayList;
    054    import java.util.List;
    055    import java.util.Locale;
    056
    057    import org.jfree.chart.event.AxisChangeEvent;
    058    import org.jfree.chart.plot.Plot;
    059    import org.jfree.chart.plot.PlotRenderingInfo;
    060    import org.jfree.chart.plot.ValueAxisPlot;
    061    import org.jfree.data.Range;
    062    import org.jfree.ui.RectangleEdge;
    063    import org.jfree.ui.RectangleInsets;
    064    import org.jfree.ui.TextAnchor;
    065
    066    /**
    067     * A numerical axis that uses a logarithmic scale.  The class is an
    068     * alternative to the {@link LogarithmicAxis} class.
    069     *
    070     * @since 1.0.7
    071     */
    072    public class LogAxis extends ValueAxis {
    073
    074        /** The logarithm base. */
    075        private double base = 10.0;
    076
    077        /** The logarithm of the base value - cached for performance. */
    078        private double baseLog = Math.log(10.0);
    079
    080        /**  The smallest value permitted on the axis. */
    081        private double smallestValue = 1E-100;
    082
    083        /** The current tick unit. */
    084        private NumberTickUnit tickUnit;
    085
    086        /** The override number format. */
    087        private NumberFormat numberFormatOverride;
    088
    089        /** The number of minor ticks per major tick unit. */
    090        private int minorTickCount;
    091
    092        /**
    093         * Creates a new <code>LogAxis</code> with no label.
    094         */
    095        public LogAxis() {
    096            this(null);
    097        }
    098
    099        /**
    100         * Creates a new <code>LogAxis</code> with the given label.
    101         *
    102         * @param label  the axis label (<code>null</code> permitted).
    103         */
    104        public LogAxis(String label) {
    105            super(label,  createLogTickUnits(Locale.getDefault()));
    106            setDefaultAutoRange(new Range(0.01, 1.0));
    107            this.tickUnit = new NumberTickUnit(1.0, new DecimalFormat("0.#"));
    108            this.minorTickCount = 10;
    109        }
    110
    111        /**
    112         * Returns the base for the logarithm calculation.
    113         *
    114         * @return The base for the logarithm calculation.
    115         *
    116         * @see #setBase(double)
    117         */
    118        public double getBase() {
    119            return this.base;
    120        }
    121
    122        /**
    123         * Sets the base for the logarithm calculation and sends an
    124         * {@link AxisChangeEvent} to all registered listeners.
    125         *
    126         * @param base  the base value (must be > 1.0).
    127         *
    128         * @see #getBase()
    129         */
    130        public void setBase(double base) {
    131            if (base <= 1.0) {
    132                throw new IllegalArgumentException("Requires 'base' > 1.0.");
    133            }
    134            this.base = base;
    135            this.baseLog = Math.log(base);
    136            notifyListeners(new AxisChangeEvent(this));
    137        }
    138
    139        /**
    140         * Returns the smallest value represented by the axis.
    141         *
    142         * @return The smallest value represented by the axis.
    143         *
    144         * @see #setSmallestValue(double)
    145         */
    146        public double getSmallestValue() {
    147            return this.smallestValue;
    148        }
    149
    150        /**
    151         * Sets the smallest value represented by the axis and sends an
    152         * {@link AxisChangeEvent} to all registered listeners.
    153         *
    154         * @param value  the value.
    155         *
    156         * @see #getSmallestValue()
    157         */
    158        public void setSmallestValue(double value) {
    159            if (value <= 0.0) {
    160                throw new IllegalArgumentException("Requires 'value' > 0.0.");
    161            }
    162            this.smallestValue = value;
    163            notifyListeners(new AxisChangeEvent(this));
    164        }
    165
    166        /**
    167         * Returns the current tick unit.
    168         *
    169         * @return The current tick unit.
    170         *
    171         * @see #setTickUnit(NumberTickUnit)
    172         */
    173        public NumberTickUnit getTickUnit() {
    174            return this.tickUnit;
    175        }
    176
    177        /**
    178         * Sets the tick unit for the axis and sends an {@link AxisChangeEvent} to
    179         * all registered listeners.  A side effect of calling this method is that
    180         * the "auto-select" feature for tick units is switched off (you can
    181         * restore it using the {@link ValueAxis#setAutoTickUnitSelection(boolean)}
    182         * method).
    183         *
    184         * @param unit  the new tick unit (<code>null</code> not permitted).
    185         *
    186         * @see #getTickUnit()
    187         */
    188        public void setTickUnit(NumberTickUnit unit) {
    189            // defer argument checking...
    190            setTickUnit(unit, true, true);
    191        }
    192
    193        /**
    194         * Sets the tick unit for the axis and, if requested, sends an
    195         * {@link AxisChangeEvent} to all registered listeners.  In addition, an
    196         * option is provided to turn off the "auto-select" feature for tick units
    197         * (you can restore it using the
    198         * {@link ValueAxis#setAutoTickUnitSelection(boolean)} method).
    199         *
    200         * @param unit  the new tick unit (<code>null</code> not permitted).
    201         * @param notify  notify listeners?
    202         * @param turnOffAutoSelect  turn off the auto-tick selection?
    203         *
    204         * @see #getTickUnit()
    205         */
    206        public void setTickUnit(NumberTickUnit unit, boolean notify,
    207                                boolean turnOffAutoSelect) {
    208
    209            if (unit == null) {
    210                throw new IllegalArgumentException("Null 'unit' argument.");
    211            }
    212            this.tickUnit = unit;
    213            if (turnOffAutoSelect) {
    214                setAutoTickUnitSelection(false, false);
    215            }
    216            if (notify) {
    217                notifyListeners(new AxisChangeEvent(this));
    218            }
    219
    220        }
    221
    222        /**
    223         * Returns the number format override.  If this is non-null, then it will
    224         * be used to format the numbers on the axis.
    225         *
    226         * @return The number formatter (possibly <code>null</code>).
    227         *
    228         * @see #setNumberFormatOverride(NumberFormat)
    229         */
    230        public NumberFormat getNumberFormatOverride() {
    231            return this.numberFormatOverride;
    232        }
    233
    234        /**
    235         * Sets the number format override.  If this is non-null, then it will be
    236         * used to format the numbers on the axis.
    237         *
    238         * @param formatter  the number formatter (<code>null</code> permitted).
    239         *
    240         * @see #getNumberFormatOverride()
    241         */
    242        public void setNumberFormatOverride(NumberFormat formatter) {
    243            this.numberFormatOverride = formatter;
    244            notifyListeners(new AxisChangeEvent(this));
    245        }
    246
    247        /**
    248         * Returns the number of minor tick marks to display.
    249         *
    250         * @return The number of minor tick marks to display.
    251         *
    252         * @see #setMinorTickCount(int)
    253         */
    254        public int getMinorTickCount() {
    255            return this.minorTickCount;
    256        }
    257
    258        /**
    259         * Sets the number of minor tick marks to display, and sends an
    260         * {@link AxisChangeEvent} to all registered listeners.
    261         *
    262         * @param count  the count.
    263         *
    264         * @see #getMinorTickCount()
    265         */
    266        public void setMinorTickCount(int count) {
    267            if (count <= 0) {
    268                throw new IllegalArgumentException("Requires 'count' > 0.");
    269            }
    270            this.minorTickCount = count;
    271            notifyListeners(new AxisChangeEvent(this));
    272        }
    273
    274        /**
    275         * Calculates the log of the given value, using the current base.
    276         *
    277         * @param value  the value.
    278         *
    279         * @return The log of the given value.
    280         *
    281         * @see #calculateValue(double)
    282         * @see #getBase()
    283         */
    284        public double calculateLog(double value) {
    285            return Math.log(value) / this.baseLog;
    286        }
    287
    288        /**
    289         * Calculates the value from a given log.
    290         *
    291         * @param log  the log value (must be > 0.0).
    292         *
    293         * @return The value with the given log.
    294         *
    295         * @see #calculateLog(double)
    296         * @see #getBase()
    297         */
    298        public double calculateValue(double log) {
    299            return Math.pow(this.base, log);
    300        }
    301
    302        /**
    303         * Converts a Java2D coordinate to an axis value, assuming that the
    304         * axis covers the specified <code>edge</code> of the <code>area</code>.
    305         *
    306         * @param java2DValue  the Java2D coordinate.
    307         * @param area  the area.
    308         * @param edge  the edge that the axis belongs to.
    309         *
    310         * @return A value along the axis scale.
    311         */
    312        public double java2DToValue(double java2DValue, Rectangle2D area,
    313                RectangleEdge edge) {
    314
    315            Range range = getRange();
    316            double axisMin = calculateLog(range.getLowerBound());
    317            double axisMax = calculateLog(range.getUpperBound());
    318
    319            double min = 0.0;
    320            double max = 0.0;
    321            if (RectangleEdge.isTopOrBottom(edge)) {
    322                min = area.getX();
    323                max = area.getMaxX();
    324            }
    325            else if (RectangleEdge.isLeftOrRight(edge)) {
    326                min = area.getMaxY();
    327                max = area.getY();
    328            }
    329            double log = 0.0;
    330            if (isInverted()) {
    331                log = axisMax - (java2DValue - min) / (max - min)
    332                        * (axisMax - axisMin);
    333            }
    334            else {
    335                log = axisMin + (java2DValue - min) / (max - min)
    336                        * (axisMax - axisMin);
    337            }
    338            return calculateValue(log);
    339        }
    340
    341        /**
    342         * Converts a value on the axis scale to a Java2D coordinate relative to
    343         * the given <code>area</code>, based on the axis running along the
    344         * specified <code>edge</code>.
    345         *
    346         * @param value  the data value.
    347         * @param area  the area.
    348         * @param edge  the edge.
    349         *
    350         * @return The Java2D coordinate corresponding to <code>value</code>.
    351         */
    352        public double valueToJava2D(double value, Rectangle2D area,
    353                RectangleEdge edge) {
    354
    355            Range range = getRange();
    356            double axisMin = calculateLog(range.getLowerBound());
    357            double axisMax = calculateLog(range.getUpperBound());
    358            value = calculateLog(value);
    359
    360            double min = 0.0;
    361            double max = 0.0;
    362            if (RectangleEdge.isTopOrBottom(edge)) {
    363                min = area.getX();
    364                max = area.getMaxX();
    365            }
    366            else if (RectangleEdge.isLeftOrRight(edge)) {
    367                max = area.getMinY();
    368                min = area.getMaxY();
    369            }
    370            if (isInverted()) {
    371                return max
    372                       - ((value - axisMin) / (axisMax - axisMin)) * (max - min);
    373            }
    374            else {
    375                return min
    376                       + ((value - axisMin) / (axisMax - axisMin)) * (max - min);
    377            }
    378        }
    379
    380        /**
    381         * Configures the axis.  This method is typically called when an axis
    382         * is assigned to a new plot.
    383         */
    384        public void configure() {
    385            if (isAutoRange()) {
    386                autoAdjustRange();
    387            }
    388        }
    389
    390        /**
    391         * Adjusts the axis range to match the data range that the axis is
    392         * required to display.
    393         */
    394        protected void autoAdjustRange() {
    395            Plot plot = getPlot();
    396            if (plot == null) {
    397                return;  // no plot, no data
    398            }
    399
    400            if (plot instanceof ValueAxisPlot) {
    401                ValueAxisPlot vap = (ValueAxisPlot) plot;
    402
    403                Range r = vap.getDataRange(this);
    404                if (r == null) {
    405                    r = getDefaultAutoRange();
    406                }
    407
    408                double upper = r.getUpperBound();
    409                double lower = Math.max(r.getLowerBound(), this.smallestValue);
    410                double range = upper - lower;
    411
    412                // if fixed auto range, then derive lower bound...
    413                double fixedAutoRange = getFixedAutoRange();
    414                if (fixedAutoRange > 0.0) {
    415                    lower = Math.max(upper - fixedAutoRange, this.smallestValue);
    416                }
    417                else {
    418                    // ensure the autorange is at least <minRange> in size...
    419                    double minRange = getAutoRangeMinimumSize();
    420                    if (range < minRange) {
    421                        double expand = (minRange - range) / 2;
    422                        upper = upper + expand;
    423                        lower = lower - expand;
    424                    }
    425
    426                    // apply the margins - these should apply to the exponent range
    427                    double logUpper = calculateLog(upper);
    428                    double logLower = calculateLog(lower);
    429                    double logRange = logUpper - logLower;
    430                    logUpper = logUpper + getUpperMargin() * logRange;
    431                    logLower = logLower - getLowerMargin() * logRange;
    432                    upper = calculateValue(logUpper);
    433                    lower = calculateValue(logLower);
    434                }
    435
    436                setRange(new Range(lower, upper), false, false);
    437            }
    438
    439        }
    440
    441        /**
    442         * Draws the axis on a Java 2D graphics device (such as the screen or a
    443         * printer).
    444         *
    445         * @param g2  the graphics device (<code>null</code> not permitted).
    446         * @param cursor  the cursor location (determines where to draw the axis).
    447         * @param plotArea  the area within which the axes and plot should be drawn.
    448         * @param dataArea  the area within which the data should be drawn.
    449         * @param edge  the axis location (<code>null</code> not permitted).
    450         * @param plotState  collects information about the plot
    451         *                   (<code>null</code> permitted).
    452         *
    453         * @return The axis state (never <code>null</code>).
    454         */
    455        public AxisState draw(Graphics2D g2, double cursor, Rectangle2D plotArea,
    456                Rectangle2D dataArea, RectangleEdge edge,
    457                PlotRenderingInfo plotState) {
    458
    459            AxisState state = null;
    460            // if the axis is not visible, don't draw it...
    461            if (!isVisible()) {
    462                state = new AxisState(cursor);
    463                // even though the axis is not visible, we need ticks for the
    464                // gridlines...
    465                List ticks = refreshTicks(g2, state, dataArea, edge);
    466                state.setTicks(ticks);
    467                return state;
    468            }
    469            state = drawTickMarksAndLabels(g2, cursor, plotArea, dataArea, edge);
    470            state = drawLabel(getLabel(), g2, plotArea, dataArea, edge, state);
    471            return state;
    472        }
    473
    474        /**
    475         * Calculates the positions of the tick labels for the axis, storing the
    476         * results in the tick label list (ready for drawing).
    477         *
    478         * @param g2  the graphics device.
    479         * @param state  the axis state.
    480         * @param dataArea  the area in which the plot should be drawn.
    481         * @param edge  the location of the axis.
    482         *
    483         * @return A list of ticks.
    484         *
    485         */
    486        public List refreshTicks(Graphics2D g2, AxisState state,
    487                Rectangle2D dataArea, RectangleEdge edge) {
    488
    489            List result = new java.util.ArrayList();
    490            if (RectangleEdge.isTopOrBottom(edge)) {
    491                result = refreshTicksHorizontal(g2, dataArea, edge);
    492            }
    493            else if (RectangleEdge.isLeftOrRight(edge)) {
    494                result = refreshTicksVertical(g2, dataArea, edge);
    495            }
    496            return result;
    497
    498        }
    499
    500        /**
    501         * Returns a list of ticks for an axis at the top or bottom of the chart.
    502         *
    503         * @param g2  the graphics device.
    504         * @param dataArea  the data area.
    505         * @param edge  the edge.
    506         *
    507         * @return A list of ticks.
    508         */
    509        protected List refreshTicksHorizontal(Graphics2D g2, Rectangle2D dataArea,
    510                RectangleEdge edge) {
    511
    512            Range range = getRange();
    513            List ticks = new ArrayList();
    514            Font tickLabelFont = getTickLabelFont();
    515            g2.setFont(tickLabelFont);
    516
    517            if (isAutoTickUnitSelection()) {
    518                selectAutoTickUnit(g2, dataArea, edge);
    519            }
    520            double start = Math.floor(calculateLog(getLowerBound()));
    521            double end = Math.ceil(calculateLog(getUpperBound()));
    522            double current = start;
    523            while (current <= end) {
    524                double v = calculateValue(current);
    525                if (range.contains(v)) {
    526                    ticks.add(new NumberTick(TickType.MAJOR, v, createTickLabel(v),
    527                            TextAnchor.TOP_CENTER, TextAnchor.CENTER, 0.0));
    528                }
    529                // add minor ticks (for gridlines)
    530                double next = Math.pow(this.base, current
    531                        + this.tickUnit.getSize());
    532                for (int i = 1; i < this.minorTickCount; i++) {
    533                    double minorV = v + i * ((next - v) / this.minorTickCount);
    534                    if (range.contains(minorV)) {
    535                        ticks.add(new NumberTick(TickType.MINOR, minorV,
    536                            "", TextAnchor.TOP_CENTER, TextAnchor.CENTER, 0.0));
    537                    }
    538                }
    539                current = current + this.tickUnit.getSize();
    540            }
    541            return ticks;
    542        }
    543
    544        /**
    545         * Returns a list of ticks for an axis at the left or right of the chart.
    546         *
    547         * @param g2  the graphics device.
    548         * @param dataArea  the data area.
    549         * @param edge  the edge.
    550         *
    551         * @return A list of ticks.
    552         */
    553        protected List refreshTicksVertical(Graphics2D g2, Rectangle2D dataArea,
    554                RectangleEdge edge) {
    555
    556            Range range = getRange();
    557            List ticks = new ArrayList();
    558            Font tickLabelFont = getTickLabelFont();
    559            g2.setFont(tickLabelFont);
    560
    561            if (isAutoTickUnitSelection()) {
    562                selectAutoTickUnit(g2, dataArea, edge);
    563            }
    564            double start = Math.floor(calculateLog(getLowerBound()));
    565            double end = Math.ceil(calculateLog(getUpperBound()));
    566            double current = start;
    567            while (current <= end) {
    568                double v = calculateValue(current);
    569                if (range.contains(v)) {
    570                    ticks.add(new NumberTick(TickType.MINOR, v, createTickLabel(v),
    571                            TextAnchor.CENTER_RIGHT, TextAnchor.CENTER, 0.0));
    572                }
    573                // add minor ticks (for gridlines)
    574                double next = Math.pow(this.base, current
    575                        + this.tickUnit.getSize());
    576                for (int i = 1; i < this.minorTickCount; i++) {
    577                    double minorV = v + i * ((next - v) / this.minorTickCount);
    578                    if (range.contains(minorV)) {
    579                        ticks.add(new NumberTick(TickType.MINOR, minorV, "",
    580                                TextAnchor.CENTER_RIGHT, TextAnchor.CENTER, 0.0));
    581                    }
    582                }
    583                current = current + this.tickUnit.getSize();
    584            }
    585            return ticks;
    586        }
    587
    588        /**
    589         * Selects an appropriate tick value for the axis.  The strategy is to
    590         * display as many ticks as possible (selected from an array of 'standard'
    591         * tick units) without the labels overlapping.
    592         *
    593         * @param g2  the graphics device.
    594         * @param dataArea  the area defined by the axes.
    595         * @param edge  the axis location.
    596         *
    597         * @since 1.0.7
    598         */
    599        protected void selectAutoTickUnit(Graphics2D g2, Rectangle2D dataArea,
    600                RectangleEdge edge) {
    601
    602            if (RectangleEdge.isTopOrBottom(edge)) {
    603                selectHorizontalAutoTickUnit(g2, dataArea, edge);
    604            }
    605            else if (RectangleEdge.isLeftOrRight(edge)) {
    606                selectVerticalAutoTickUnit(g2, dataArea, edge);
    607            }
    608
    609        }
    610
    611        /**
    612         * Selects an appropriate tick value for the axis.  The strategy is to
    613         * display as many ticks as possible (selected from an array of 'standard'
    614         * tick units) without the labels overlapping.
    615         *
    616         * @param g2  the graphics device.
    617         * @param dataArea  the area defined by the axes.
    618         * @param edge  the axis location.
    619         *
    620         * @since 1.0.7
    621         */
    622       protected void selectHorizontalAutoTickUnit(Graphics2D g2,
    623               Rectangle2D dataArea, RectangleEdge edge) {
    624
    625            double tickLabelWidth = estimateMaximumTickLabelWidth(g2,
    626                    getTickUnit());
    627
    628            // start with the current tick unit...
    629            TickUnitSource tickUnits = getStandardTickUnits();
    630            TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
    631            double unit1Width = exponentLengthToJava2D(unit1.getSize(), dataArea,
    632                    edge);
    633
    634            // then extrapolate...
    635            double guess = (tickLabelWidth / unit1Width) * unit1.getSize();
    636
    637            NumberTickUnit unit2 = (NumberTickUnit)
    638                    tickUnits.getCeilingTickUnit(guess);
    639            double unit2Width = exponentLengthToJava2D(unit2.getSize(), dataArea,
    640                    edge);
    641
    642            tickLabelWidth = estimateMaximumTickLabelWidth(g2, unit2);
    643            if (tickLabelWidth > unit2Width) {
    644                unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
    645            }
    646
    647            setTickUnit(unit2, false, false);
    648
    649        }
    650
    651        /**
    652         * Converts a length in data coordinates into the corresponding length in
    653         * Java2D coordinates.
    654         *
    655         * @param length  the length.
    656         * @param area  the plot area.
    657         * @param edge  the edge along which the axis lies.
    658         *
    659         * @return The length in Java2D coordinates.
    660         *
    661         * @since 1.0.7
    662         */
    663        public double exponentLengthToJava2D(double length, Rectangle2D area,
    664                                    RectangleEdge edge) {
    665            double one = valueToJava2D(calculateValue(1.0), area, edge);
    666            double l = valueToJava2D(calculateValue(length + 1.0), area, edge);
    667            return Math.abs(l - one);
    668        }
    669
    670        /**
    671         * Selects an appropriate tick value for the axis.  The strategy is to
    672         * display as many ticks as possible (selected from an array of 'standard'
    673         * tick units) without the labels overlapping.
    674         *
    675         * @param g2  the graphics device.
    676         * @param dataArea  the area in which the plot should be drawn.
    677         * @param edge  the axis location.
    678         *
    679         * @since 1.0.7
    680         */
    681        protected void selectVerticalAutoTickUnit(Graphics2D g2,
    682                                                  Rectangle2D dataArea,
    683                                                  RectangleEdge edge) {
    684
    685            double tickLabelHeight = estimateMaximumTickLabelHeight(g2);
    686
    687            // start with the current tick unit...
    688            TickUnitSource tickUnits = getStandardTickUnits();
    689            TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
    690            double unitHeight = exponentLengthToJava2D(unit1.getSize(), dataArea,
    691                    edge);
    692
    693            // then extrapolate...
    694            double guess = (tickLabelHeight / unitHeight) * unit1.getSize();
    695
    696            NumberTickUnit unit2 = (NumberTickUnit)
    697                    tickUnits.getCeilingTickUnit(guess);
    698            double unit2Height = exponentLengthToJava2D(unit2.getSize(), dataArea,
    699                    edge);
    700
    701            tickLabelHeight = estimateMaximumTickLabelHeight(g2);
    702            if (tickLabelHeight > unit2Height) {
    703                unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
    704            }
    705
    706            setTickUnit(unit2, false, false);
    707
    708        }
    709
    710        /**
    711         * Estimates the maximum tick label height.
    712         *
    713         * @param g2  the graphics device.
    714         *
    715         * @return The maximum height.
    716         *
    717         * @since 1.0.7
    718         */
    719        protected double estimateMaximumTickLabelHeight(Graphics2D g2) {
    720
    721            RectangleInsets tickLabelInsets = getTickLabelInsets();
    722            double result = tickLabelInsets.getTop() + tickLabelInsets.getBottom();
    723
    724            Font tickLabelFont = getTickLabelFont();
    725            FontRenderContext frc = g2.getFontRenderContext();
    726            result += tickLabelFont.getLineMetrics("123", frc).getHeight();
    727            return result;
    728
    729        }
    730
    731        /**
    732         * Estimates the maximum width of the tick labels, assuming the specified
    733         * tick unit is used.
    734         * <P>
    735         * Rather than computing the string bounds of every tick on the axis, we
    736         * just look at two values: the lower bound and the upper bound for the
    737         * axis.  These two values will usually be representative.
    738         *
    739         * @param g2  the graphics device.
    740         * @param unit  the tick unit to use for calculation.
    741         *
    742         * @return The estimated maximum width of the tick labels.
    743         *
    744         * @since 1.0.7
    745         */
    746        protected double estimateMaximumTickLabelWidth(Graphics2D g2,
    747                                                       TickUnit unit) {
    748
    749            RectangleInsets tickLabelInsets = getTickLabelInsets();
    750            double result = tickLabelInsets.getLeft() + tickLabelInsets.getRight();
    751
    752            if (isVerticalTickLabels()) {
    753                // all tick labels have the same width (equal to the height of the
    754                // font)...
    755                FontRenderContext frc = g2.getFontRenderContext();
    756                LineMetrics lm = getTickLabelFont().getLineMetrics("0", frc);
    757                result += lm.getHeight();
    758            }
    759            else {
    760                // look at lower and upper bounds...
    761                FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
    762                Range range = getRange();
    763                double lower = range.getLowerBound();
    764                double upper = range.getUpperBound();
    765                String lowerStr = "";
    766                String upperStr = "";
    767                NumberFormat formatter = getNumberFormatOverride();
    768                if (formatter != null) {
    769                    lowerStr = formatter.format(lower);
    770                    upperStr = formatter.format(upper);
    771                }
    772                else {
    773                    lowerStr = unit.valueToString(lower);
    774                    upperStr = unit.valueToString(upper);
    775                }
    776                double w1 = fm.stringWidth(lowerStr);
    777                double w2 = fm.stringWidth(upperStr);
    778                result += Math.max(w1, w2);
    779            }
    780
    781            return result;
    782
    783        }
    784
    785        /**
    786         * Zooms in on the current range.
    787         *
    788         * @param lowerPercent  the new lower bound.
    789         * @param upperPercent  the new upper bound.
    790         */
    791        public void zoomRange(double lowerPercent, double upperPercent) {
    792            Range range = getRange();
    793            double start = range.getLowerBound();
    794            double end = range.getUpperBound();
    795            double log1 = calculateLog(start);
    796            double log2 = calculateLog(end);
    797            double length = log2 - log1;
    798            Range adjusted = null;
    799            if (isInverted()) {
    800                double logA = log1 + length * (1 - upperPercent);
    801                double logB = log1 + length * (1 - lowerPercent);
    802                adjusted = new Range(calculateValue(logA), calculateValue(logB));
    803            }
    804            else {
    805                double logA = log1 + length * lowerPercent;
    806                double logB = log1 + length * upperPercent;
    807                adjusted = new Range(calculateValue(logA), calculateValue(logB));
    808            }
    809            setRange(adjusted);
    810        }
    811
    812        /**
    813         * Creates a tick label for the specified value.
    814         *
    815         * @param value  the value.
    816         *
    817         * @return The label.
    818         */
    819        private String createTickLabel(double value) {
    820            if (this.numberFormatOverride != null) {
    821                return this.numberFormatOverride.format(value);
    822            }
    823            else {
    824                return this.tickUnit.valueToString(value);
    825            }
    826        }
    827
    828        /**
    829         * Tests this axis for equality with an arbitrary object.
    830         *
    831         * @param obj  the object (<code>null</code> permitted).
    832         *
    833         * @return A boolean.
    834         */
    835        public boolean equals(Object obj) {
    836            if (obj == this) {
    837                return true;
    838            }
    839            if (!(obj instanceof LogAxis)) {
    840                return false;
    841            }
    842            LogAxis that = (LogAxis) obj;
    843            if (this.base != that.base) {
    844                return false;
    845            }
    846            if (this.smallestValue != that.smallestValue) {
    847                return false;
    848            }
    849            if (this.minorTickCount != that.minorTickCount) {
    850                return false;
    851            }
    852            return super.equals(obj);
    853        }
    854
    855        /**
    856         * Returns a hash code for this instance.
    857         *
    858         * @return A hash code.
    859         */
    860        public int hashCode() {
    861            int result = 193;
    862            long temp = Double.doubleToLongBits(this.base);
    863            result = 37 * result + (int) (temp ^ (temp >>> 32));
    864            result = 37 * result + this.minorTickCount;
    865            temp = Double.doubleToLongBits(this.smallestValue);
    866            result = 37 * result + (int) (temp ^ (temp >>> 32));
    867            if (this.numberFormatOverride != null) {
    868                result = 37 * result + this.numberFormatOverride.hashCode();
    869            }
    870            result = 37 * result + this.tickUnit.hashCode();
    871            return result;
    872        }
    873
    874        /**
    875         * Returns a collection of tick units for log (base 10) values.
    876         * Uses a given Locale to create the DecimalFormats.
    877         *
    878         * @param locale the locale to use to represent Numbers.
    879         *
    880         * @return A collection of tick units for integer values.
    881         *
    882         * @since 1.0.7
    883         */
    884        public static TickUnitSource createLogTickUnits(Locale locale) {
    885
    886            TickUnits units = new TickUnits();
    887
    888            NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);
    889
    890            units.add(new NumberTickUnit(1, numberFormat));
    891            units.add(new NumberTickUnit(2, numberFormat));
    892            units.add(new NumberTickUnit(5, numberFormat));
    893            units.add(new NumberTickUnit(10, numberFormat));
    894            units.add(new NumberTickUnit(20, numberFormat));
    895            units.add(new NumberTickUnit(50, numberFormat));
    896            units.add(new NumberTickUnit(100, numberFormat));
    897            units.add(new NumberTickUnit(200, numberFormat));
    898            units.add(new NumberTickUnit(500, numberFormat));
    899            units.add(new NumberTickUnit(1000, numberFormat));
    900            units.add(new NumberTickUnit(2000, numberFormat));
    901            units.add(new NumberTickUnit(5000, numberFormat));
    902            units.add(new NumberTickUnit(10000, numberFormat));
    903            units.add(new NumberTickUnit(20000, numberFormat));
    904            units.add(new NumberTickUnit(50000, numberFormat));
    905            units.add(new NumberTickUnit(100000, numberFormat));
    906            units.add(new NumberTickUnit(200000,         numberFormat));
    907            units.add(new NumberTickUnit(500000,         numberFormat));
    908            units.add(new NumberTickUnit(1000000,        numberFormat));
    909            units.add(new NumberTickUnit(2000000,        numberFormat));
    910            units.add(new NumberTickUnit(5000000,        numberFormat));
    911            units.add(new NumberTickUnit(10000000,       numberFormat));
    912            units.add(new NumberTickUnit(20000000,       numberFormat));
    913            units.add(new NumberTickUnit(50000000,       numberFormat));
    914            units.add(new NumberTickUnit(100000000,      numberFormat));
    915            units.add(new NumberTickUnit(200000000,      numberFormat));
    916            units.add(new NumberTickUnit(500000000,      numberFormat));
    917            units.add(new NumberTickUnit(1000000000,     numberFormat));
    918            units.add(new NumberTickUnit(2000000000,     numberFormat));
    919            units.add(new NumberTickUnit(5000000000.0,   numberFormat));
    920            units.add(new NumberTickUnit(10000000000.0,  numberFormat));
    921
    922            return units;
    923
    924        }
    925    }