    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2008, 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     * StatisticalLineAndShapeRenderer.java
    029     * ------------------------------------
    030     * (C) Copyright 2005-2008, by Object Refinery Limited and Contributors.
    031     *
    032     * Original Author:  Mofeed Shahin;
    033     * Contributor(s):   David Gilbert (for Object Refinery Limited);
    034     *
    035     * Changes
    036     * -------
    037     * 01-Feb-2005 : Version 1, contributed by Mofeed Shahin (DG);
    038     * 16-Jun-2005 : Added errorIndicatorPaint to be consistent with
    039     *               StatisticalBarRenderer (DG);
    040     * ------------- JFREECHART 1.0.x ---------------------------------------------
    041     * 11-Apr-2006 : Fixed bug 1468794, error bars drawn incorrectly when rendering
    042     *               plots with horizontal orientation (DG);
    043     * 25-Sep-2006 : Fixed bug 1562759, constructor ignoring arguments (DG);
    044     * 01-Jun-2007 : Return early from drawItem() method if item is not
    045     *               visible (DG);
    046     * 14-Jun-2007 : If the dataset is not a StatisticalCategoryDataset, revert
    047     *               to the drawing behaviour of LineAndShapeRenderer (DG);
    048     * 27-Sep-2007 : Added offset option to match new option in
    049     *               LineAndShapeRenderer (DG);
    050     *
    051     */
    052
    053    package org.jfree.chart.renderer.category;
    054
    055    import java.awt.Graphics2D;
    056    import java.awt.Paint;
    057    import java.awt.Shape;
    058    import java.awt.geom.Line2D;
    059    import java.awt.geom.Rectangle2D;
    060    import java.io.IOException;
    061    import java.io.ObjectInputStream;
    062    import java.io.ObjectOutputStream;
    063    import java.io.Serializable;
    064
    065    import org.jfree.chart.axis.CategoryAxis;
    066    import org.jfree.chart.axis.ValueAxis;
    067    import org.jfree.chart.entity.EntityCollection;
    068    import org.jfree.chart.event.RendererChangeEvent;
    069    import org.jfree.chart.plot.CategoryPlot;
    070    import org.jfree.chart.plot.PlotOrientation;
    071    import org.jfree.data.category.CategoryDataset;
    072    import org.jfree.data.statistics.StatisticalCategoryDataset;
    073    import org.jfree.io.SerialUtilities;
    074    import org.jfree.ui.RectangleEdge;
    075    import org.jfree.util.PaintUtilities;
    076    import org.jfree.util.PublicCloneable;
    077    import org.jfree.util.ShapeUtilities;
    078
    079    /**
    080     * A renderer that draws shapes for each data item, and lines between data
    081     * items.  Each point has a mean value and a standard deviation line. For use
    082     * with the {@link CategoryPlot} class.
    083     */
    084    public class StatisticalLineAndShapeRenderer extends LineAndShapeRenderer
    085            implements Cloneable, PublicCloneable, Serializable {
    086
    087        /** For serialization. */
    088        private static final long serialVersionUID = -3557517173697777579L;
    089
    090        /** The paint used to show the error indicator. */
    091        private transient Paint errorIndicatorPaint;
    092
    093        /**
    094         * Constructs a default renderer (draws shapes and lines).
    095         */
    096        public StatisticalLineAndShapeRenderer() {
    097            this(true, true);
    098        }
    099
    100        /**
    101         * Constructs a new renderer.
    102         *
    103         * @param linesVisible  draw lines?
    104         * @param shapesVisible  draw shapes?
    105         */
    106        public StatisticalLineAndShapeRenderer(boolean linesVisible,
    107                                               boolean shapesVisible) {
    108            super(linesVisible, shapesVisible);
    109            this.errorIndicatorPaint = null;
    110        }
    111
    112        /**
    113         * Returns the paint used for the error indicators.
    114         *
    115         * @return The paint used for the error indicators (possibly
    116         *         <code>null</code>).
    117         *
    118         * @see #setErrorIndicatorPaint(Paint)
    119         */
    120        public Paint getErrorIndicatorPaint() {
    121            return this.errorIndicatorPaint;
    122        }
    123
    124        /**
    125         * Sets the paint used for the error indicators (if <code>null</code>,
    126         * the item outline paint is used instead) and sends a
    127         * {@link RendererChangeEvent} to all registered listeners.
    128         *
    129         * @param paint  the paint (<code>null</code> permitted).
    130         *
    131         * @see #getErrorIndicatorPaint()
    132         */
    133        public void setErrorIndicatorPaint(Paint paint) {
    134            this.errorIndicatorPaint = paint;
    135            fireChangeEvent();
    136        }
    137
    138        /**
    139         * Draw a single data item.
    140         *
    141         * @param g2  the graphics device.
    142         * @param state  the renderer state.
    143         * @param dataArea  the area in which the data is drawn.
    144         * @param plot  the plot.
    145         * @param domainAxis  the domain axis.
    146         * @param rangeAxis  the range axis.
    147         * @param dataset  the dataset (a {@link StatisticalCategoryDataset} is
    148         *                 required).
    149         * @param row  the row index (zero-based).
    150         * @param column  the column index (zero-based).
    151         * @param pass  the pass.
    152         */
    153        public void drawItem(Graphics2D g2,
    154                             CategoryItemRendererState state,
    155                             Rectangle2D dataArea,
    156                             CategoryPlot plot,
    157                             CategoryAxis domainAxis,
    158                             ValueAxis rangeAxis,
    159                             CategoryDataset dataset,
    160                             int row,
    161                             int column,
    162                             int pass) {
    163
    164            // do nothing if item is not visible
    165            if (!getItemVisible(row, column)) {
    166                return;
    167            }
    168
    169            // nothing is drawn for null...
    170            Number v = dataset.getValue(row, column);
    171            if (v == null) {
    172                return;
    173            }
    174
    175            // if the dataset is not a StatisticalCategoryDataset then just revert
    176            // to the superclass (LineAndShapeRenderer) behaviour...
    177            if (!(dataset instanceof StatisticalCategoryDataset)) {
    178                super.drawItem(g2, state, dataArea, plot, domainAxis, rangeAxis,
    179                        dataset, row, column, pass);
    180                return;
    181            }
    182
    183            StatisticalCategoryDataset statData
    184                    = (StatisticalCategoryDataset) dataset;
    185
    186            Number meanValue = statData.getMeanValue(row, column);
    187
    188            PlotOrientation orientation = plot.getOrientation();
    189
    190            // current data point...
    191            double x1;
    192            if (getUseSeriesOffset()) {
    193                x1 = domainAxis.getCategorySeriesMiddle(dataset.getColumnKey(
    194                        column), dataset.getRowKey(row), dataset, getItemMargin(),
    195                        dataArea, plot.getDomainAxisEdge());
    196            }
    197            else {
    198                x1 = domainAxis.getCategoryMiddle(column, getColumnCount(),
    199                        dataArea, plot.getDomainAxisEdge());
    200            }
    201
    202            double y1 = rangeAxis.valueToJava2D(meanValue.doubleValue(), dataArea,
    203                    plot.getRangeAxisEdge());
    204
    205            Shape shape = getItemShape(row, column);
    206            if (orientation == PlotOrientation.HORIZONTAL) {
    207                shape = ShapeUtilities.createTranslatedShape(shape, y1, x1);
    208            }
    209            else if (orientation == PlotOrientation.VERTICAL) {
    210                shape = ShapeUtilities.createTranslatedShape(shape, x1, y1);
    211            }
    212            if (getItemShapeVisible(row, column)) {
    213
    214                if (getItemShapeFilled(row, column)) {
    215                    g2.setPaint(getItemPaint(row, column));
    216                    g2.fill(shape);
    217                }
    218                else {
    219                    if (getUseOutlinePaint()) {
    220                        g2.setPaint(getItemOutlinePaint(row, column));
    221                    }
    222                    else {
    223                        g2.setPaint(getItemPaint(row, column));
    224                    }
    225                    g2.setStroke(getItemOutlineStroke(row, column));
    226                    g2.draw(shape);
    227                }
    228            }
    229
    230            if (getItemLineVisible(row, column)) {
    231                if (column != 0) {
    232
    233                    Number previousValue = statData.getValue(row, column - 1);
    234                    if (previousValue != null) {
    235
    236                        // previous data point...
    237                        double previous = previousValue.doubleValue();
    238                        double x0;
    239                        if (getUseSeriesOffset()) {
    240                            x0 = domainAxis.getCategorySeriesMiddle(
    241                                    dataset.getColumnKey(column - 1),
    242                                    dataset.getRowKey(row), dataset,
    243                                    getItemMargin(), dataArea,
    244                                    plot.getDomainAxisEdge());
    245                        }
    246                        else {
    247                            x0 = domainAxis.getCategoryMiddle(column - 1,
    248                                    getColumnCount(), dataArea,
    249                                    plot.getDomainAxisEdge());
    250                        }
    251                        double y0 = rangeAxis.valueToJava2D(previous, dataArea,
    252                                plot.getRangeAxisEdge());
    253
    254                        Line2D line = null;
    255                        if (orientation == PlotOrientation.HORIZONTAL) {
    256                            line = new Line2D.Double(y0, x0, y1, x1);
    257                        }
    258                        else if (orientation == PlotOrientation.VERTICAL) {
    259                            line = new Line2D.Double(x0, y0, x1, y1);
    260                        }
    261                        g2.setPaint(getItemPaint(row, column));
    262                        g2.setStroke(getItemStroke(row, column));
    263                        g2.draw(line);
    264                    }
    265                }
    266            }
    267
    268            RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
    269            g2.setPaint(getItemPaint(row, column));
    270
    271            //standard deviation lines
    272            double valueDelta = statData.getStdDevValue(row, column).doubleValue();
    273
    274            double highVal, lowVal;
    275            if ((meanValue.doubleValue() + valueDelta)
    276                    > rangeAxis.getRange().getUpperBound()) {
    277                highVal = rangeAxis.valueToJava2D(
    278                        rangeAxis.getRange().getUpperBound(), dataArea,
    279                        yAxisLocation);
    280            }
    281            else {
    282                highVal = rangeAxis.valueToJava2D(meanValue.doubleValue()
    283                        + valueDelta, dataArea, yAxisLocation);
    284            }
    285
    286            if ((meanValue.doubleValue() + valueDelta)
    287                    < rangeAxis.getRange().getLowerBound()) {
    288                lowVal = rangeAxis.valueToJava2D(
    289                        rangeAxis.getRange().getLowerBound(), dataArea,
    290                        yAxisLocation);
    291            }
    292            else {
    293                lowVal = rangeAxis.valueToJava2D(meanValue.doubleValue()
    294                        - valueDelta, dataArea, yAxisLocation);
    295            }
    296
    297            if (this.errorIndicatorPaint != null) {
    298                g2.setPaint(this.errorIndicatorPaint);
    299            }
    300            else {
    301                g2.setPaint(getItemPaint(row, column));
    302            }
    303            Line2D line = new Line2D.Double();
    304            if (orientation == PlotOrientation.HORIZONTAL) {
    305                line.setLine(lowVal, x1, highVal, x1);
    306                g2.draw(line);
    307                line.setLine(lowVal, x1 - 5.0d, lowVal, x1 + 5.0d);
    308                g2.draw(line);
    309                line.setLine(highVal, x1 - 5.0d, highVal, x1 + 5.0d);
    310                g2.draw(line);
    311            }
    312            else {  // PlotOrientation.VERTICAL
    313                line.setLine(x1, lowVal, x1, highVal);
    314                g2.draw(line);
    315                line.setLine(x1 - 5.0d, highVal, x1 + 5.0d, highVal);
    316                g2.draw(line);
    317                line.setLine(x1 - 5.0d, lowVal, x1 + 5.0d, lowVal);
    318                g2.draw(line);
    319            }
    320
    321            // draw the item label if there is one...
    322            if (isItemLabelVisible(row, column)) {
    323                if (orientation == PlotOrientation.HORIZONTAL) {
    324                    drawItemLabel(g2, orientation, dataset, row, column,
    325                            y1, x1, (meanValue.doubleValue() < 0.0));
    326                }
    327                else if (orientation == PlotOrientation.VERTICAL) {
    328                    drawItemLabel(g2, orientation, dataset, row, column,
    329                            x1, y1, (meanValue.doubleValue() < 0.0));
    330                }
    331            }
    332
    333            // add an item entity, if this information is being collected
    334            EntityCollection entities = state.getEntityCollection();
    335            if (entities != null && shape != null) {
    336                addItemEntity(entities, dataset, row, column, shape);
    337            }
    338
    339        }
    340
    341        /**
    342         * Tests this renderer for equality with an arbitrary object.
    343         *
    344         * @param obj  the object (<code>null</code> permitted).
    345         *
    346         * @return A boolean.
    347         */
    348        public boolean equals(Object obj) {
    349            if (obj == this) {
    350                return true;
    351            }
    352            if (!(obj instanceof StatisticalLineAndShapeRenderer)) {
    353                return false;
    354            }
    355            StatisticalLineAndShapeRenderer that
    356                    = (StatisticalLineAndShapeRenderer) obj;
    357            if (!PaintUtilities.equal(this.errorIndicatorPaint,
    358                    that.errorIndicatorPaint)) {
    359                return false;
    360            }
    361            return super.equals(obj);
    362        }
    363
    364        /**
    365         * Provides serialization support.
    366         *
    367         * @param stream  the output stream.
    368         *
    369         * @throws IOException  if there is an I/O error.
    370         */
    371        private void writeObject(ObjectOutputStream stream) throws IOException {
    372            stream.defaultWriteObject();
    373            SerialUtilities.writePaint(this.errorIndicatorPaint, stream);
    374        }
    375
    376        /**
    377         * Provides serialization support.
    378         *
    379         * @param stream  the input stream.
    380         *
    381         * @throws IOException  if there is an I/O error.
    382         * @throws ClassNotFoundException  if there is a classpath problem.
    383         */
    384        private void readObject(ObjectInputStream stream)
    385                throws IOException, ClassNotFoundException {
    386            stream.defaultReadObject();
    387            this.errorIndicatorPaint = SerialUtilities.readPaint(stream);
    388        }
    389
    390    }