Example usage for org.jfree.data.xy DefaultIntervalXYDataset addSeries

List of usage examples for org.jfree.data.xy DefaultIntervalXYDataset addSeries

  1. HOME
  2. Java
  3. org.jfree
  4. org.jfree.data.xy.*
  5. DefaultIntervalXYDataset
  6. addSeries

Introduction

In this page you can find the example usage for org.jfree.data.xy DefaultIntervalXYDataset addSeries.

Prototype

public void addSeries(Comparable seriesKey, double[][] data)

Source Link

Document

Adds a series or if a series with the same key already exists replaces the data for that series, then sends a DatasetChangeEvent to all registered listeners.

Usage

From source file:graph.jfreecharts.GraphFunction.java

/**
 * Plots an xyerror graph using jfreecharts
 * @param title the title of the graph//from w  w w  .jav  a  2 s. c om
 * @param xlabel the x axis title
 * @param ylabel the y axis title
 * @param legend the legend
 * @param data the data values
 */
protected static void plotData(String title, String xlabel, String ylabel, String[] legend, double[][][] data) {

    DefaultIntervalXYDataset xydata = new DefaultIntervalXYDataset();

    for (int i = 0; i < legend.length; i++) {
        xydata.addSeries(legend[i], data[i]);
    }
    // create a chart...
    JFreeChart chart = GraphFunction.createXYIntervalChart(title, xlabel, ylabel, xydata,
            PlotOrientation.VERTICAL, true, true, false);
    // create and display a frame...
    ChartFrame frame = new ChartFrame("First", chart);
    frame.pack();
    frame.setVisible(true);
    frame.setDefaultCloseOperation(javax.swing.JFrame.DISPOSE_ON_CLOSE);
}

From source file:org.jfree.chart.demo.XYBarChartDemo6.java

private static IntervalXYDataset createDataset() {
    DefaultIntervalXYDataset defaultintervalxydataset = new DefaultIntervalXYDataset();
    double ad[] = { 1.0D, 2D, 3D, 4D };
    double ad1[] = { 0.90000000000000002D, 1.8D, 2.7000000000000002D, 3.6000000000000001D };
    double ad2[] = { 1.1000000000000001D, 2.2000000000000002D, 3.2999999999999998D, 4.4000000000000004D };
    double ad3[] = { 1.0D, 2D, 3D, 4D };
    double ad4[] = { 0.90000000000000002D, 1.8D, 2.7000000000000002D, 3.6000000000000001D };
    double ad5[] = { 1.1000000000000001D, 2.2000000000000002D, 3.2999999999999998D, 4.4000000000000004D };
    double ad6[][] = { ad, ad1, ad2, ad3, ad4, ad5 };
    defaultintervalxydataset.addSeries("Series 1", ad6);
    return defaultintervalxydataset;
}

From source file:org.pentaho.reporting.engine.classic.extensions.legacy.charts.LegacyChartType.java

private XYDataset createIntervalXYDataset() {
    final DefaultIntervalXYDataset dataset = new DefaultIntervalXYDataset();
    dataset.addSeries("First",
            new double[][] { { 1, 2, 3 }, { 3, 1, 2 }, { 1, 2, 1 }, { 4, 4, 4 }, { 3, 3, 3 }, { 4, 4, 4 }, });// NON-NLS
    // dataset.addSeries("Second", new double[][]{{1, 2, 3}, {3, 0, 1}, {1, 2,
    // 3}, {3, 0, 1}, {1, 2, 3}, {3, 0, 1}, });//NON-NLS
    return dataset;
}

From source file:org.jfree.data.xy.DefaultIntervalXYDatasetTest.java

/**
 * Some tests for the addSeries() method.
 *//* w w  w.j  ava  2s .  c o m*/
@Test
public void testAddSeries() {
    DefaultIntervalXYDataset d = new DefaultIntervalXYDataset();
    d.addSeries("S1", new double[][] { { 1.0 }, { 0.5 }, { 1.5 }, { 2.0 }, { 2.5 }, { 1.5 } });
    assertEquals(1, d.getSeriesCount());
    assertEquals("S1", d.getSeriesKey(0));

    // check that adding a series will overwrite the old series
    d.addSeries("S1", new double[][] { { 1.1 }, { 0.6 }, { 1.6 }, { 2.1 }, { 2.6 }, { 1.6 } });
    assertEquals(1, d.getSeriesCount());
    assertEquals(2.1, d.getYValue(0, 0), EPSILON);

    // check null key
    boolean pass = false;
    try {
        d.addSeries(null, new double[][] { { 1.1 }, { 0.6 }, { 1.6 }, { 2.1 }, { 2.6 }, { 1.6 } });
    } catch (IllegalArgumentException e) {
        pass = true;
    }
    assertTrue(pass);
}

From source file:org.jfree.data.xy.junit.DefaultIntervalXYDatasetTest.java

/**
 * Some tests for the addSeries() method.
 *///w  w w.j ava2  s .c om
public void testAddSeries() {
    DefaultIntervalXYDataset d = new DefaultIntervalXYDataset();
    d.addSeries("S1", new double[][] { { 1.0 }, { 0.5 }, { 1.5 }, { 2.0 }, { 2.5 }, { 1.5 } });
    assertEquals(1, d.getSeriesCount());
    assertEquals("S1", d.getSeriesKey(0));

    // check that adding a series will overwrite the old series
    d.addSeries("S1", new double[][] { { 1.1 }, { 0.6 }, { 1.6 }, { 2.1 }, { 2.6 }, { 1.6 } });
    assertEquals(1, d.getSeriesCount());
    assertEquals(2.1, d.getYValue(0, 0), EPSILON);

    // check null key
    boolean pass = false;
    try {
        d.addSeries(null, new double[][] { { 1.1 }, { 0.6 }, { 1.6 }, { 2.1 }, { 2.6 }, { 1.6 } });
    } catch (IllegalArgumentException e) {
        pass = true;
    }
    assertTrue(pass);
}

From source file:org.jfree.data.xy.DefaultIntervalXYDatasetTest.java

/**
 * Another test for cloning.//from   w w  w. j a v  a 2  s  .  c o  m
 */
@Test
public void testCloning2() throws CloneNotSupportedException {
    DefaultIntervalXYDataset d1 = new DefaultIntervalXYDataset();
    double[] x1 = new double[] { 1.0, 2.0, 3.0 };
    double[] x1Start = new double[] { 0.9, 1.9, 2.9 };
    double[] x1End = new double[] { 1.1, 2.1, 3.1 };
    double[] y1 = new double[] { 4.0, 5.0, 6.0 };
    double[] y1Start = new double[] { 1.09, 2.09, 3.09 };
    double[] y1End = new double[] { 1.11, 2.11, 3.11 };
    double[][] data1 = new double[][] { x1, x1Start, x1End, y1, y1Start, y1End };
    d1.addSeries("S1", data1);
    DefaultIntervalXYDataset d2 = (DefaultIntervalXYDataset) d1.clone();
    assertTrue(d1 != d2);
    assertTrue(d1.getClass() == d2.getClass());
    assertTrue(d1.equals(d2));

    // check independence
    x1[0] = 111.1;
    assertFalse(d1.equals(d2));
}

From source file:org.jfree.data.xy.DefaultIntervalXYDatasetTest.java

/**
 * Creates a sample dataset for testing.
 *
 * @return A sample dataset.//from   w  w w.  j a v a  2  s  .c o  m
 */
public DefaultIntervalXYDataset createSampleDataset1() {
    DefaultIntervalXYDataset d = new DefaultIntervalXYDataset();
    double[] x1 = new double[] { 1.0, 2.0, 3.0 };
    double[] x1Start = new double[] { 0.9, 1.9, 2.9 };
    double[] x1End = new double[] { 1.1, 2.1, 3.1 };
    double[] y1 = new double[] { 4.0, 5.0, 6.0 };
    double[] y1Start = new double[] { 1.09, 2.09, 3.09 };
    double[] y1End = new double[] { 1.11, 2.11, 3.11 };
    double[][] data1 = new double[][] { x1, x1Start, x1End, y1, y1Start, y1End };
    d.addSeries("S1", data1);

    double[] x2 = new double[] { 11.0, 12.0, 13.0 };
    double[] x2Start = new double[] { 10.9, 11.9, 12.9 };
    double[] x2End = new double[] { 11.1, 12.1, 13.1 };
    double[] y2 = new double[] { 14.0, 15.0, 16.0 };
    double[] y2Start = new double[] { 11.09, 12.09, 13.09 };
    double[] y2End = new double[] { 11.11, 12.11, 13.11 };
    double[][] data2 = new double[][] { x2, x2Start, x2End, y2, y2Start, y2End };
    d.addSeries("S2", data2);
    return d;
}

From source file:org.jfree.data.xy.junit.DefaultIntervalXYDatasetTest.java

/**
 * Another test for cloning.//from w  w  w .j a va  2 s .  co  m
 */
public void testCloning2() {
    DefaultIntervalXYDataset d1 = new DefaultIntervalXYDataset();
    double[] x1 = new double[] { 1.0, 2.0, 3.0 };
    double[] x1Start = new double[] { 0.9, 1.9, 2.9 };
    double[] x1End = new double[] { 1.1, 2.1, 3.1 };
    double[] y1 = new double[] { 4.0, 5.0, 6.0 };
    double[] y1Start = new double[] { 1.09, 2.09, 3.09 };
    double[] y1End = new double[] { 1.11, 2.11, 3.11 };
    double[][] data1 = new double[][] { x1, x1Start, x1End, y1, y1Start, y1End };
    d1.addSeries("S1", data1);
    DefaultIntervalXYDataset d2 = null;
    try {
        d2 = (DefaultIntervalXYDataset) d1.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    assertTrue(d1 != d2);
    assertTrue(d1.getClass() == d2.getClass());
    assertTrue(d1.equals(d2));

    // check independence
    x1[0] = 111.1;
    assertFalse(d1.equals(d2));
}

From source file:org.pentaho.aggdes.ui.form.controller.AggListController.java

public void changeInAggregates() {

    // set dirty bit for workspace
    workspace.setWorkspaceUpToDate(false);

    // set the dirty bit for the schema publishing functionality

    if (getConnectionModel().getSchema() != null) {
        getConnectionModel().setSchemaUpToDate(false);
    }/* w w w  .j  a v  a2  s  . c  o m*/

    // configure summary model and chart values

    int totalAggregatesSelected = 0;
    double totalRows = 0;
    double totalSpace = 0;
    double totalLoadTime = 0;

    //Fire event
    AggListController.this.firePropertyChange("aggList", null, aggList);

    List<Aggregate> algoAggregates = new ArrayList<Aggregate>();
    for (UIAggregate aggregate : getAggList()) {
        if (aggregate.getEnabled()) {
            totalAggregatesSelected++;
            totalRows += aggregate.estimateRowCount();
            totalSpace += aggregate.estimateSpace();
            algoAggregates
                    .add(algorithm.createAggregate(connectionModel.getSchema(), aggregate.getAttributes()));
        }
    }

    double[] xs = new double[algoAggregates.size()];
    double[] startx = new double[algoAggregates.size()];
    double[] endx = new double[algoAggregates.size()];

    double[] ys = new double[algoAggregates.size()];
    double[] starty = new double[algoAggregates.size()];
    double[] endy = new double[algoAggregates.size()];

    XYSeries series1 = new XYSeries("CostBenefit");
    XYSeriesCollection dataset = new XYSeriesCollection();
    dataset.addSeries(series1);
    DefaultIntervalXYDataset datasetxy = new DefaultIntervalXYDataset();

    if (connectionModel.getSchema() != null) {

        Map<Parameter, Object> algorithmParams = ArgumentUtils.validateParameters(algorithm,
                algorithmUiExtension.getAlgorithmParameters());
        List<Algorithm.CostBenefit> costBenefit = algorithm.computeAggregateCosts(connectionModel.getSchema(),
                algorithmParams, algoAggregates);

        double totalbenefit = 0;
        double x = 0;
        int count = 0;
        for (Algorithm.CostBenefit cb : costBenefit) {
            Aggregate agg = algoAggregates.get(count);
            double estimateSpace = agg.estimateSpace();
            double hx = estimateSpace / 2;
            totalLoadTime += cb.getLoadTime();
            totalbenefit += cb.getSavedQueryRowCount();
            series1.add(x + hx, totalbenefit);

            xs[count] = x + hx;
            startx[count] = x;
            x += estimateSpace;
            endx[count] = x;

            ys[count] = totalbenefit;
            starty[count] = 0;
            endy[count] = 0;

            count++;
        }

        // update summary table

        aggregateSummaryModel.setSelectedAggregateCount(format.format(totalAggregatesSelected));
        aggregateSummaryModel.setSelectedAggregateRows(format.format(totalRows));
        aggregateSummaryModel.setSelectedAggregateSpace(format.format(totalSpace) + " bytes");
        aggregateSummaryModel.setSelectedAggregateLoadTime(format.format(totalLoadTime));
    } else {
        aggregateSummaryModel.setSelectedAggregateCount("");
        aggregateSummaryModel.setSelectedAggregateRows("");
        aggregateSummaryModel.setSelectedAggregateSpace("");
        aggregateSummaryModel.setSelectedAggregateLoadTime("");

    }
    // render cost benefit chart

    double[][] data = new double[][] { xs, startx, endx, ys, starty, endy };
    datasetxy.addSeries("", data);

    JFreeChart chart = ChartFactory.createXYBarChart("", // chart title
            "Cost", // x axis label
            false, "Benefit", // y axis label
            datasetxy, // data
            PlotOrientation.VERTICAL, // orientation
            false, // include legend
            false, // tooltips?
            false // URLs?
    );

    ((XYPlot) chart.getPlot()).getDomainAxis().setTickLabelsVisible(false);
    ((XYPlot) chart.getPlot()).getRangeAxis().setTickLabelsVisible(false);
    ((XYPlot) chart.getPlot()).setDataset(1, dataset);
    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();

    chart.setBackgroundPaint(
            new Color(Integer.parseInt(Messages.getString("chart_background_color").toUpperCase(), 16)));

    renderer.setSeriesPaint(0,
            new Color(Integer.parseInt(Messages.getString("chart_line_color").toUpperCase(), 16)));

    ((XYPlot) chart.getPlot()).getRenderer(0).setSeriesPaint(0,
            new Color(Integer.parseInt(Messages.getString("chart_bar_color").toUpperCase(), 16)));

    ((XYPlot) chart.getPlot()).setRenderer(1, renderer);
    ((XYPlot) chart.getPlot()).setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
    XulImage image = (XulImage) document.getElementById("chart");
    image.setSrc(chart.createBufferedImage(309, 168));
}