cyclicxyitemrenderer.java

这是一个segy数据显示程序

/* ===========================================================
 * JFreeChart : a free chart library for the Java(tm) platform
 * ===========================================================
 *
 * (C) Copyright 2000-2004, 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., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
 * in the United States and other countries.]
 *
 * ---------------------------
 * CyclicXYItemRenderer.java
 * ---------------------------
 * (C) Copyright 2003, 2004, by Nicolas Brodu and Contributors.
 *
 * Original Author:  Nicolas Brodu;
 * Contributor(s):   David Gilbert (for Object Refinery Limited);
 *
 * $Id: CyclicXYItemRenderer.java,v 1.9 2004/05/06 08:16:49 mungady Exp $
 *
 * Changes
 * -------
 * 19-Nov-2003 : Initial import to JFreeChart from the JSynoptic project (NB);
 * 23-Dec-2003 : Added missing Javadocs (DG);
 * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG);
 * 
 */

package org.jfree.chart.renderer;

import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;

import org.jfree.chart.axis.CyclicNumberAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.labels.XYToolTipGenerator;
import org.jfree.chart.plot.CrosshairState;
import org.jfree.chart.plot.PlotRenderingInfo;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.urls.XYURLGenerator;
import org.jfree.data.DatasetChangeListener;
import org.jfree.data.DatasetGroup;
import org.jfree.data.XYDataset;

/**
 * The Cyclic XY item renderer is specially designed to handle cyclic axis. 
 * While the standard renderer would draw a line across the plot when a cycling occurs, the cyclic
 * renderer splits the line at each cycle end instead. This is done by interpolating new points at 
 * cycle boundary. Thus, correct appearance is restored. 
 * 
 * The Cyclic XY item renderer works exactly like a standard XY item renderer with non-cyclic axis. 
 *
 * @author Nicolas Brodu
 */
public class CyclicXYItemRenderer extends StandardXYItemRenderer {

    /**
     * Default constructor.
     */
    public CyclicXYItemRenderer() {
        super();
    }

    /**
     * Creates a new renderer.
     * 
     * @param type  the renderer type.
     */
    public CyclicXYItemRenderer(int type) {
        super(type);
    }

    /**
     * Creates a new renderer.
     * 
     * @param type  the renderer type.
     * @param labelGenerator  the tooltip generator.
     */
    public CyclicXYItemRenderer(int type, XYToolTipGenerator labelGenerator) {
        super(type, labelGenerator);
    }

    /**
     * Creates a new renderer.
     * 
     * @param type  the renderer type.
     * @param labelGenerator  the tooltip generator.
     * @param urlGenerator  the url generator.
     */
    public CyclicXYItemRenderer(int type, 
                                XYToolTipGenerator labelGenerator,
                                XYURLGenerator urlGenerator) {
        super(type, labelGenerator, urlGenerator);
    }

    
    /** 
     * Draws the visual representation of a single data item.
     * When using cyclic axis, do not draw a line from right to left when cycling as would a 
     * standard XY item renderer, but instead draw a line from the previous point to the cycle bound
     * in the last cycle, and a line from the cycle bound to current point in the current cycle.  
     * 
     * @param g2  the graphics device.
     * @param state  the renderer state.
     * @param dataArea  the data area.
     * @param info  the plot rendering info.
     * @param plot  the plot.
     * @param domainAxis  the domain axis.
     * @param rangeAxis  the range axis.
     * @param dataset  the dataset.
     * @param series  the series index.
     * @param item  the item index.
     * @param crosshairState  crosshair information for the plot (<code>null</code> permitted).
     * @param pass  the current pass index.
     */
    public void drawItem(Graphics2D g2, 
                         XYItemRendererState state,
                         Rectangle2D dataArea, 
                         PlotRenderingInfo info, 
                         XYPlot plot,
                         ValueAxis domainAxis, 
                         ValueAxis rangeAxis, 
                         XYDataset dataset,
                         int series, 
                         int item, 
                         CrosshairState crosshairState, 
                         int pass) {

        if ((!getPlotLines()) || ((!(domainAxis instanceof CyclicNumberAxis)) 
                && (!(rangeAxis instanceof CyclicNumberAxis))) || (item <= 0)) {
            super.drawItem(
                g2, state, dataArea, info, plot, domainAxis, rangeAxis, dataset, series, item, 
                crosshairState, pass
            );
            return;
        }

        // get the previous data point...
        Number xn = dataset.getXValue(series, item - 1);
        Number yn = dataset.getYValue(series, item - 1);
        // If null, don't draw line => then delegate to parent
        if (yn == null || xn == null) {
            super.drawItem(
                g2, state, dataArea, info, plot, domainAxis, rangeAxis, dataset, series, item, 
                crosshairState, pass
            );
            return;
        }
        double[] x = new double[2];
        double[] y = new double[2];
        x[0] = xn.doubleValue();
        y[0] = yn.doubleValue();
        
        // get the data point...
        xn = dataset.getXValue(series, item);
        yn = dataset.getYValue(series, item);
        // If null, don't draw line at all
        if (yn == null || xn == null) {
            return;
        }
        x[1] = xn.doubleValue();
        y[1] = yn.doubleValue();

        // Now split the segment as needed
        double xcycleBound = Double.NaN;
        double ycycleBound = Double.NaN;
        boolean xBoundMapping = false, yBoundMapping = false;
        CyclicNumberAxis cnax = null, cnay = null;

        if (domainAxis instanceof CyclicNumberAxis) {
            cnax = (CyclicNumberAxis) domainAxis;
            xcycleBound = cnax.getCycleBound();
            xBoundMapping = cnax.isBoundMappedToLastCycle();
            // If the segment must be splitted, insert a new point
            // Strict test forces to have real segments (not 2 equal points) and avoids 
            // division by 0 
            if ((x[0] != x[1]) && ((xcycleBound >= x[0]) && (xcycleBound <= x[1]) 
                    || (xcycleBound >= x[1]) && (xcycleBound <= x[0]))) {
                double[] nx = new double[3];
                double[] ny = new double[3];
                nx[0] = x[0]; nx[2] = x[1]; ny[0] = y[0]; ny[2] = y[1];
                nx[1] = xcycleBound;
                ny[1] = (y[1] - y[0]) * (xcycleBound - x[0]) / (x[1] - x[0]) + y[0];
                x = nx; y = ny;
            }
        }

        if (rangeAxis instanceof CyclicNumberAxis) {
            cnay = (CyclicNumberAxis) rangeAxis;
            ycycleBound = cnay.getCycleBound();
            yBoundMapping = cnay.isBoundMappedToLastCycle();
            // The split may occur in either x splitted segments, if any, but not in both
            if ((y[0] != y[1]) && ((ycycleBound >= y[0]) && (ycycleBound <= y[1]) 
                    || (ycycleBound >= y[1]) && (ycycleBound <= y[0]))) {
                double[] nx = new double[x.length + 1];
                double[] ny = new double[y.length + 1];
                nx[0] = x[0]; nx[2] = x[1]; ny[0] = y[0]; ny[2] = y[1];
                ny[1] = ycycleBound;
                nx[1] = (x[1] - x[0]) * (ycycleBound - y[0]) / (y[1] - y[0]) + x[0];
                if (x.length == 3) { 
                    nx[3] = x[2]; ny[3] = y[2]; 
                }
                x = nx; y = ny;
            }
            else if ((x.length == 3) && (y[1] != y[2]) && ((ycycleBound >= y[1]) 
                    && (ycycleBound <= y[2]) ||  (ycycleBound >= y[2]) && (ycycleBound <= y[1]))) {
                double[] nx = new double[4];
                double[] ny = new double[4];
                nx[0] = x[0]; nx[1] = x[1]; nx[3] = x[2]; 
                ny[0] = y[0]; ny[1] = y[1]; ny[3] = y[2];
                ny[2] = ycycleBound;
                nx[2] = (x[2] - x[1]) * (ycycleBound - y[1]) / (y[2] - y[1]) + x[1];
                x = nx; y = ny;
            }
        }
        
        // If the line is not wrapping, then parent is OK
        if (x.length == 2) {
            super.drawItem(
                g2, state, dataArea, info, plot, domainAxis, rangeAxis, dataset, 
                series, item, crosshairState, pass
            );
            return;