xydifferencerenderer.java

大家打开看看啊, 很有用的东西

                               int item,
                               CrosshairInfo crosshairInfo) {

        Shape entityArea = null;
        EntityCollection entities = null;
        if (info != null) {
            entities = info.getEntityCollection();
        }

        Paint seriesPaint = getItemPaint(series, item);
        Stroke seriesStroke = getItemStroke(series, item);
        g2.setPaint(seriesPaint);
        g2.setStroke(seriesStroke);

        if (series == 0) {

            // get the data points...
            Number x0n = dataset.getXValue(0, item);
            Number y0n = dataset.getYValue(0, item);
            Number x1n = dataset.getXValue(1, item);
            Number y1n = dataset.getYValue(1, item);

            RectangleEdge domainAxisLocation = plot.getDomainAxisEdge();
            RectangleEdge rangeAxisLocation = plot.getRangeAxisEdge();

            double x0 = x0n.doubleValue();
            double y0 = y0n.doubleValue();
            double transX0 = domainAxis.translateValueToJava2D(x0, dataArea, domainAxisLocation);
            double transY0 = rangeAxis.translateValueToJava2D(y0, dataArea, rangeAxisLocation);

            double x1 = x1n.doubleValue();
            double y1 = y1n.doubleValue();
            double transX1 = domainAxis.translateValueToJava2D(x1, dataArea, domainAxisLocation);
            double transY1 = rangeAxis.translateValueToJava2D(y1, dataArea, rangeAxisLocation);

            if (item > 0) {
                // get the previous data points...
                // get the data points...
                Number prevx0n = dataset.getXValue(0, item - 1);
                Number prevy0n = dataset.getYValue(0, item - 1);
                Number prevx1n = dataset.getXValue(1, item - 1);
                Number prevy1n = dataset.getYValue(1, item - 1);

                double prevx0 = prevx0n.doubleValue();
                double prevy0 = prevy0n.doubleValue();
                double prevtransX0 = domainAxis.translateValueToJava2D(prevx0, dataArea, 
                                                                       domainAxisLocation);
                double prevtransY0 = rangeAxis.translateValueToJava2D(prevy0, dataArea, 
                                                                      rangeAxisLocation);

                double prevx1 = prevx1n.doubleValue();
                double prevy1 = prevy1n.doubleValue();
                double prevtransX1 = domainAxis.translateValueToJava2D(prevx1, dataArea, 
                                                                       domainAxisLocation);
                double prevtransY1 = rangeAxis.translateValueToJava2D(prevy1, dataArea, 
                                                                      rangeAxisLocation);

                Line2D line0 = new Line2D.Double(transX0, transY0, prevtransX0, prevtransY0);
                if (line0.intersects(dataArea)) {
                    g2.setPaint(getItemPaint(series, item));
                    g2.draw(line0);
                }
                Line2D line1 = new Line2D.Double(transX1, transY1, prevtransX1, prevtransY1);
                if (line1.intersects(dataArea)) {
                    g2.setPaint(getItemPaint(1, item));
                    g2.draw(line1);
                }
            }

            if (this.plotShapes) {
                Shape shape0 = getItemShape(series, item);
                shape0 = createTransformedShape(shape0, transX0, transY0);
                if (shape0.intersects(dataArea)) {
                    g2.setPaint(getItemPaint(series, item));
                    g2.fill(shape0);
                }
                entityArea = shape0;

                // add an entity for the item...
                if (entities != null) {
                    if (entityArea == null) {
                        entityArea = new Rectangle2D.Double(transX0 - 2, transY0 - 2, 4, 4);
                    }
                    String tip = null;
                    if (getToolTipGenerator() != null) {
                        tip = getToolTipGenerator().generateToolTip(dataset, series, item);
                    }
                    String url = null;
                    if (getURLGenerator() != null) {
                        url = getURLGenerator().generateURL(dataset, series, item);
                    }
                    XYItemEntity entity = new XYItemEntity(entityArea, dataset, series, item, tip, url);
                    entities.addEntity(entity);
                }

                Shape shape1 = getItemShape(series + 1, item);
                shape1 = createTransformedShape(shape1, transX1, transY1);
                if (shape1.intersects(dataArea)) {
                    g2.setPaint(getItemPaint(series + 1, item));
                    g2.fill(shape1);
                }
                entityArea = shape1;

                // add an entity for the item...
                if (entities != null) {
                    if (entityArea == null) {
                        entityArea = new Rectangle2D.Double(transX1 - 2, transY1 - 2, 4, 4);
                    }
                    String tip = null;
                    if (getToolTipGenerator() != null) {
                        tip = getToolTipGenerator().generateToolTip(dataset, series + 1, item);
                    }
                    String url = null;
                    if (getURLGenerator() != null) {
                        url = getURLGenerator().generateURL(dataset, series + 1, item);
                    }
                    XYItemEntity entity = new XYItemEntity(entityArea, dataset, series + 1, item, 
                                                           tip, url);
                    entities.addEntity(entity);
                }
            }

        }

    }

    /**
     * Returns the positive area for a crossover point.
     * 
     * @param x0  x coordinate.
     * @param y0A  y coordinate A.
     * @param y0B  y coordinate B.
     * @param x1  x coordinate.
     * @param y1A  y coordinate A.
     * @param y1B  y coordinate B.
     * 
     * @return The positive area.
     */
    private Shape getPositiveArea(float x0, float y0A, float y0B, float x1, float y1A, float y1B) {

        Shape result = null;

        if (y0A >= y0B) {  // negative
            if (y1A >= y1B) {
                // all negative - return null
            }
            else {
                // changed from negative to positive
                //this.positivePaint = Color.yellow;
                float[] p = getIntersection(x0, y0A, x1, y1A, x0, y0B, x1, y1B);
                GeneralPath area = new GeneralPath();
                area.moveTo(x1, y1A);
                area.lineTo(p[0], p[1]);
                area.lineTo(x1, y1B);
                area.closePath();
                result = area;
            }
        }
        else {
            if (y1A >= y1B) {
                // changed from positive to negative
                //this.positivePaint = Color.green;
                float[] p = getIntersection(x0, y0A, x1, y1A, x0, y0B, x1, y1B);
                GeneralPath area = new GeneralPath();
                area.moveTo(x0, y0A);
                area.lineTo(p[0], p[1]);
                area.lineTo(x0, y0B);
                area.closePath();
                result = area;

            }
            else {
                //this.positivePaint = Color.blue;
                GeneralPath area = new GeneralPath();
                area.moveTo(x0, y0A);
                area.lineTo(x1, y1A);
                area.lineTo(x1, y1B);
                area.lineTo(x0, y0B);
                area.closePath();
                result = area;
            }

        }

        return result;

    }

    /**
     * Returns the negative area for a cross-over section.
     * 
     * @param x0  x coordinate.
     * @param y0A  y coordinate A.
     * @param y0B  y coordinate B.
     * @param x1  x coordinate.
     * @param y1A  y coordinate A.
     * @param y1B  y coordinate B.
     * 
     * @return The negative area.
     */
    private Shape getNegativeArea(float x0, float y0A, float y0B, float x1, float y1A, float y1B) {

        Shape result = null;

        if (y0A >= y0B) {  // negative
            if (y1A >= y1B) {  // negative
                //this.negativePaint = Color.red;
                GeneralPath area = new GeneralPath();
                area.moveTo(x0, y0A);
                area.lineTo(x1, y1A);
                area.lineTo(x1, y1B);
                area.lineTo(x0, y0B);
                area.closePath();
                result = area;
            }
            else {  // changed from negative to positive

                //this.negativePaint = Color.pink;
                float[] p = getIntersection(x0, y0A, x1, y1A, x0, y0B, x1, y1B);
                GeneralPath area = new GeneralPath();
                area.moveTo(x0, y0A);
                area.lineTo(p[0], p[1]);
                area.lineTo(x0, y0B);
                area.closePath();
                result = area;
            }
        }
        else {
            if (y1A >= y1B) {
                // changed from positive to negative
                //this.negativePaint = Color.gray;
                float[] p = getIntersection(x0, y0A, x1, y1A, x0, y0B, x1, y1B);
                GeneralPath area = new GeneralPath();
                area.moveTo(x1, y1A);
                area.lineTo(p[0], p[1]);
                area.lineTo(x1, y1B);
                area.closePath();
                result = area;
            }
            else {
                // all negative - return null
            }

        }

        return result;

    }

    /**
     * Returns the intersection point of two lines.
     * 
     * @param x1  x1
     * @param y1  y1
     * @param x2  x2
     * @param y2  y2
     * @param x3  x3
     * @param y3  y3
     * @param x4  x4
     * @param y4  y4
     * 
     * @return The intersection point.
     */
    private float[] getIntersection(float x1, float y1, float x2, float y2,
                                    float x3, float y3, float x4, float y4) {

        float n = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
        float d = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
        float u = n / d;

        float[] result = new float[2];
        result[0] = x1 + u * (x2 - x1);
        result[1] = y1 + u * (y2 - y1);
        return result;

    }

}