Example usage for org.jfree.chart.renderer.xy XYErrorRenderer setSeriesStroke

List of usage examples for org.jfree.chart.renderer.xy XYErrorRenderer setSeriesStroke

Introduction

In this page you can find the example usage for org.jfree.chart.renderer.xy XYErrorRenderer setSeriesStroke.

Prototype

public void setSeriesStroke(int series, Stroke stroke) 

Source Link

Document

Sets the stroke used for a series and sends a RendererChangeEvent to all registered listeners.

Usage

From source file:weka.classifiers.timeseries.eval.graph.JFreeChartDriver.java

protected JFreeChart getFutureForecastChart(TSForecaster forecaster, List<List<NumericPrediction>> preds,
        List<String> targetNames, Instances history) {

    if (forecaster instanceof TSLagUser && history != null) {
        TSLagMaker lagMaker = ((TSLagUser) forecaster).getTSLagMaker();
        if (lagMaker.getAdjustForTrends() && !lagMaker.isUsingAnArtificialTimeIndex()) {

            // fill in any missing time stamps only
            history = new Instances(history);
            history = weka.classifiers.timeseries.core.Utils.replaceMissing(history, null,
                    lagMaker.getTimeStampField(), true, lagMaker.getPeriodicity(), lagMaker.getSkipEntries());
        }/* w  w w .ja v  a  2  s.c o  m*/
    }

    // set up a collection of series
    XYIntervalSeriesCollection xyDataset = new XYIntervalSeriesCollection();

    if (history != null) {
        // add actual historical data values
        for (String targetName : targetNames) {
            XYIntervalSeries targetSeries = new XYIntervalSeries(targetName, false, false);
            xyDataset.addSeries(targetSeries);
        }
    }

    // add predicted series
    for (String targetName : targetNames) {
        XYIntervalSeries targetSeries = new XYIntervalSeries(targetName + "-predicted", false, false);
        xyDataset.addSeries(targetSeries);
    }

    ValueAxis timeAxis = null;
    NumberAxis valueAxis = new NumberAxis("");
    valueAxis.setAutoRangeIncludesZero(false);
    int timeIndex = -1;
    boolean timeAxisIsDate = false;
    double artificialTimeStart = 0;
    double lastRealTimeValue = Utils.missingValue();
    if (forecaster instanceof TSLagUser && history != null) {
        TSLagMaker lagMaker = ((TSLagUser) forecaster).getTSLagMaker();
        if (!lagMaker.isUsingAnArtificialTimeIndex() && lagMaker.getAdjustForTrends()) {
            String timeName = lagMaker.getTimeStampField();
            if (history.attribute(timeName).isDate()) {
                timeAxis = new DateAxis("");
                timeAxisIsDate = true;
                timeIndex = history.attribute(timeName).index();
            }
        } else {
            try {
                artificialTimeStart = (history != null) ? 1 : lagMaker.getArtificialTimeStartValue() + 1;
            } catch (Exception ex) {
            }
        }
    }

    if (timeAxis == null) {
        timeAxis = new NumberAxis("");
        ((NumberAxis) timeAxis).setAutoRangeIncludesZero(false);
    }

    boolean hasConfidenceIntervals = false;

    // now populate the series
    if (history != null) {

        // do the actuals first
        for (int i = 0; i < history.numInstances(); i++) {
            Instance current = history.instance(i);

            for (String targetName : targetNames) {
                int dataIndex = history.attribute(targetName.trim()).index();

                if (dataIndex >= 0) {
                    XYIntervalSeries actualSeries = null;
                    int actualIndex = xyDataset.indexOf(targetName);
                    actualSeries = xyDataset.getSeries(actualIndex);
                    double x = Utils.missingValue();

                    if (timeAxisIsDate) {
                        x = current.value(timeIndex);
                        if (!Utils.isMissingValue(x)) {
                            lastRealTimeValue = x;
                        }
                    } else {
                        x = artificialTimeStart;
                    }

                    double y = Utils.missingValue();
                    y = current.value(dataIndex);

                    if (!Utils.isMissingValue(x) && !Utils.isMissingValue(y)) {
                        if (actualSeries != null) {
                            actualSeries.add(x, x, x, y, y, y);
                        }
                    }
                }
            }

            if (!timeAxisIsDate) {
                artificialTimeStart++;
            }
        }
    }

    // now do the futures
    List<String> forecasterTargets = AbstractForecaster.stringToList(forecaster.getFieldsToForecast());

    // loop over the steps
    for (int j = 0; j < preds.size(); j++) {
        List<NumericPrediction> predsForStepJ = preds.get(j);

        // advance the real time index (if appropriate)
        if (timeAxisIsDate) {
            lastRealTimeValue = ((TSLagUser) forecaster).getTSLagMaker()
                    .advanceSuppliedTimeValue(lastRealTimeValue);
        }
        for (String targetName : targetNames) {

            // look up this requested target in the list that the forecaster
            // has predicted
            int predIndex = forecasterTargets.indexOf(targetName.trim());
            if (predIndex >= 0) {
                NumericPrediction predsForTargetAtStepJ = predsForStepJ.get(predIndex);
                XYIntervalSeries predSeries = null;
                int datasetIndex = xyDataset.indexOf(targetName + "-predicted");
                predSeries = xyDataset.getSeries(datasetIndex);

                if (predSeries != null) {
                    double y = predsForTargetAtStepJ.predicted();
                    double x = Utils.missingValue();
                    double yHigh = y;
                    double yLow = y;
                    double[][] conf = predsForTargetAtStepJ.predictionIntervals();
                    if (conf.length > 0) {
                        yLow = conf[0][0];
                        yHigh = conf[0][1];
                        hasConfidenceIntervals = true;
                    }

                    if (!timeAxisIsDate) {
                        x = artificialTimeStart;
                    } else {
                        x = lastRealTimeValue;
                    }

                    if (!Utils.isMissingValue(x) && !Utils.isMissingValue(y)) {
                        predSeries.add(x, x, x, y, yLow, yHigh);
                    }
                }
            }
        }

        // advance the artificial time index (if appropriate)
        if (!timeAxisIsDate) {
            artificialTimeStart++;
        }
    }

    String title = "Future forecast for: ";
    for (String s : targetNames) {
        title += s + ",";
    }
    title = title.substring(0, title.lastIndexOf(","));

    /*
     * String algoSpec = forecaster.getAlgorithmName(); title += " (" + algoSpec
     * + ")";
     */

    if (forecaster instanceof WekaForecaster && hasConfidenceIntervals) {
        double confPerc = ((WekaForecaster) forecaster).getConfidenceLevel() * 100.0;
        title += " [" + Utils.doubleToString(confPerc, 0) + "% conf. intervals]";
    }

    XYErrorRenderer renderer = new XYErrorRenderer();

    // renderer.setShapesFilled(true);
    XYPlot plot = new XYPlot(xyDataset, timeAxis, valueAxis, renderer);
    // renderer = (XYErrorRenderer)plot.getRenderer();
    if (history != null) {
        for (String targetName : targetNames) {
            XYIntervalSeries predSeries = null;
            int predIndex = xyDataset.indexOf(targetName + "-predicted");
            predSeries = xyDataset.getSeries(predIndex);

            XYIntervalSeries actualSeries = null;
            int actualIndex = xyDataset.indexOf(targetName);
            actualSeries = xyDataset.getSeries(actualIndex);

            if (actualSeries != null && predSeries != null) {
                // match the color of the actual series
                java.awt.Paint actualPaint = renderer.lookupSeriesPaint(actualIndex);
                renderer.setSeriesPaint(predIndex, actualPaint);

                // now set the line style to dashed
                BasicStroke dashed = new BasicStroke(1.5f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f,
                        new float[] { 5.0f }, 0.0f);

                renderer.setSeriesStroke(predIndex, dashed);
            }
        }
    }

    renderer.setBaseLinesVisible(true);
    renderer.setDrawXError(false);
    renderer.setDrawYError(true);

    JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT, plot, true);
    chart.setBackgroundPaint(java.awt.Color.white);
    TextTitle chartTitle = chart.getTitle();
    String fontName = chartTitle.getFont().getFontName();
    java.awt.Font newFont = new java.awt.Font(fontName, java.awt.Font.PLAIN, 12);
    chartTitle.setFont(newFont);

    return chart;
}

From source file:jhplot.HChart.java

/**
 * Draw data from a P1D. Drawing updated automatically. 1st level errors are
 * shown if the dimension is above 5. Otherwise show X and Y. If you set
 * setChartPolar() before,m you can also show polar coordinates.
 * //w w  w . j  a  va 2  s . c o  m
 * @param d
 *            input P1D container
 */
public void add(P1D d) {

    if (cdatPolar[N1][N2] != null) {
        XYSeries SerData = new XYSeries(d.getTitle());
        for (int i = 0; i < d.size(); i++)
            SerData.add(d.getX(i), d.getY(i));
        cdatPolar[N1][N2].addSeries(SerData);
        return; // return if this is polar chart
    }

    // assume XY chart

    // System.out.println(d.dimension());
    LinePars lpp = d.getDrawOption();
    float width = (float) lpp.getPenWidth();
    int style = d.getLineStyle();
    float dash = lpp.getDashLength();
    int symbol = lpp.getSymbol();
    Shape shape = getShape(symbol, lpp.getSymbolSize());

    // setSeriesShapesFilled(int series, java.lang.Boolean flag)
    // setShapesFilled(boolean filled)

    if (d.dimension() > 5) {
        XYIntervalSeriesCollection c = new XYIntervalSeriesCollection();
        XYIntervalSeries SerData = new XYIntervalSeries(d.getTitle());
        for (int i = 0; i < d.size(); i++)
            SerData.add(d.getX(i), d.getX(i) - d.getXleft(i), d.getX(i) + d.getXright(i), d.getY(i),
                    d.getY(i) - d.getYlower(i), d.getY(i) + d.getYupper(i));
        c.addSeries(SerData);
        xyplot[N1][N2].setDataset(indexdat[N1][N2], c);

        XYErrorRenderer xyerrorrenderer = new XYErrorRenderer();
        xyerrorrenderer.setSeriesStroke(0, getStrokes(style, width, dash));
        xyerrorrenderer.setSeriesPaint(0, d.getColor());
        xyerrorrenderer.setSeriesOutlinePaint(0, d.getColor());
        xyerrorrenderer.setSeriesFillPaint(0, lpp.getFillColor());
        xyerrorrenderer.setSeriesShape(0, shape);
        if (symbol > 0 && symbol < 4)
            xyerrorrenderer.setSeriesShapesFilled(0, false);
        if (symbol > 3)
            xyerrorrenderer.setSeriesShapesFilled(0, true);

        rdat[N1][N2].add(xyerrorrenderer);
        type[N1][N2].put(new Integer(indexdat[N1][N2]), "pe");
        indexdat[N1][N2]++;

    } else if (d.dimension() == 4) {
        XYIntervalSeriesCollection c = new XYIntervalSeriesCollection();
        XYIntervalSeries SerData = new XYIntervalSeries(d.getTitle());
        for (int i = 0; i < d.size(); i++)
            SerData.add(d.getX(i), d.getX(i), d.getX(i), d.getY(i), d.getY(i) - d.getYlower(i),
                    d.getY(i) + d.getYupper(i));

        c.addSeries(SerData);
        xyplot[N1][N2].setDataset(indexdat[N1][N2], c);

        XYErrorRenderer xyerrorrenderer = new XYErrorRenderer();
        xyerrorrenderer.setSeriesStroke(0, getStrokes(style, width, dash));
        xyerrorrenderer.setSeriesPaint(0, d.getColor());
        xyerrorrenderer.setSeriesOutlinePaint(0, d.getColor());
        xyerrorrenderer.setSeriesFillPaint(0, lpp.getFillColor());
        xyerrorrenderer.setSeriesShape(0, shape);
        if (symbol > 0 && symbol < 4)
            xyerrorrenderer.setSeriesShapesFilled(0, false);
        if (symbol > 3)
            xyerrorrenderer.setSeriesShapesFilled(0, true);

        rdat[N1][N2].add(xyerrorrenderer);
        type[N1][N2].put(new Integer(indexdat[N1][N2]), "pe");
        indexdat[N1][N2]++;

    } else if (d.dimension() == 3) {
        XYIntervalSeriesCollection c = new XYIntervalSeriesCollection();
        XYIntervalSeries SerData = new XYIntervalSeries(d.getTitle());
        for (int i = 0; i < d.size(); i++)
            SerData.add(d.getX(i), d.getX(i), d.getX(i), d.getY(i), d.getY(i) - d.getYupper(i),
                    d.getY(i) + d.getYupper(i));

        c.addSeries(SerData);
        xyplot[N1][N2].setDataset(indexdat[N1][N2], c);

        XYErrorRenderer xyerrorrenderer = new XYErrorRenderer();
        xyerrorrenderer.setSeriesStroke(0, getStrokes(style, width, dash));
        xyerrorrenderer.setSeriesPaint(0, d.getColor());
        xyerrorrenderer.setSeriesOutlinePaint(0, d.getColor());
        xyerrorrenderer.setSeriesFillPaint(0, lpp.getFillColor());
        xyerrorrenderer.setSeriesShape(0, shape);
        if (symbol > 0 && symbol < 4)
            xyerrorrenderer.setSeriesShapesFilled(0, false);
        if (symbol > 3)
            xyerrorrenderer.setSeriesShapesFilled(0, true);

        rdat[N1][N2].add(xyerrorrenderer);
        type[N1][N2].put(new Integer(indexdat[N1][N2]), "pe");
        indexdat[N1][N2]++;

    } else {
        XYSeriesCollection c = new XYSeriesCollection();
        XYSeries SerData = new XYSeries(d.getTitle());
        for (int i = 0; i < d.size(); i++)
            SerData.add(d.getX(i), d.getY(i));
        c.addSeries(SerData);
        xyplot[N1][N2].setDataset(indexdat[N1][N2], c);

        XYLineAndShapeRenderer xyerrorrenderer = new XYLineAndShapeRenderer(false, true);
        xyerrorrenderer.setSeriesStroke(0, getStrokes(style, width, dash));
        xyerrorrenderer.setSeriesPaint(0, d.getColor());
        xyerrorrenderer.setSeriesOutlinePaint(0, d.getColor());

        xyerrorrenderer.setSeriesFillPaint(0, lpp.getFillColor());
        xyerrorrenderer.setSeriesShape(0, shape);
        if (symbol > 0 && symbol < 4)
            xyerrorrenderer.setSeriesShapesFilled(0, false);
        if (symbol > 3)
            xyerrorrenderer.setSeriesShapesFilled(0, true);

        rdat[N1][N2].add(xyerrorrenderer);
        type[N1][N2].put(new Integer(indexdat[N1][N2]), "p");
        indexdat[N1][N2]++;

    }

}