Example usage for org.jfree.chart.renderer.xy XYLineAndShapeRenderer XYLineAndShapeRenderer

List of usage examples for org.jfree.chart.renderer.xy XYLineAndShapeRenderer XYLineAndShapeRenderer

Introduction

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

Prototype

public XYLineAndShapeRenderer(boolean lines, boolean shapes) 

Source Link

Document

Creates a new renderer.

Usage

From source file:de.bund.bfr.knime.pmm.common.chart.ChartCreator.java

private void plotDataSetStrict(XYPlot plot, Plotable plotable, String id) throws ConvertException {
    String legend = shortLegend.get(id);
    List<Color> colorList = colorLists.get(id);
    List<Shape> shapeList = shapeLists.get(id);
    ColorAndShapeCreator creator = new ColorAndShapeCreator(plotable.getNumberOfCombinations());
    int index = 0;

    if (addInfoInLegend) {
        legend = longLegend.get(id);/*from   www.ja  v a2s.  c  o  m*/
    }

    if (colorList == null || colorList.isEmpty()) {
        colorList = creator.getColorList();
    }

    if (shapeList == null || shapeList.isEmpty()) {
        shapeList = creator.getShapeList();
    }

    for (Map<String, Integer> choiceMap : plotable.getAllChoices()) {
        double[][] dataPoints = plotable.getPoints(paramX, paramY, unitX, unitY, transformX, transformY,
                choiceMap);

        if (dataPoints != null) {
            DefaultXYDataset dataSet = new DefaultXYDataset();
            XYLineAndShapeRenderer dataRenderer = new XYLineAndShapeRenderer(drawLines, true);
            String addLegend = "";

            for (String arg : choiceMap.keySet()) {
                if (!arg.equals(paramX)) {
                    addLegend += " (" + arg + "="
                            + plotable.getFunctionArguments().get(arg).get(choiceMap.get(arg)) + ")";
                }
            }

            dataSet.addSeries(legend + addLegend, dataPoints);
            dataRenderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
            dataRenderer.setSeriesPaint(0, colorList.get(index));
            dataRenderer.setSeriesShape(0, shapeList.get(index));

            int i;

            if (plot.getDataset(0) == null) {
                i = 0;
            } else {
                i = plot.getDatasetCount();
            }

            plot.setDataset(i, dataSet);
            plot.setRenderer(i, dataRenderer);
        }

        index++;
    }
}

From source file:com.joey.software.regionSelectionToolkit.controlers.ImageProfileTool.java

public boolean updatePlotPanel() {

    if (isBlockUpdate()) {
        return false;
    }// w w  w .  ja v a2 s  .  com

    if (realTimeImage.isSelected()) {
        previewPanel.setImage(getFlattenedImage());
    }
    // Chack data size of
    int length = getDataLength();

    if (xData.length != length) {
        xData = new float[length];
    }

    if (aScan.length != length) {
        aScan = new float[length];
    }

    // Update X Range
    float[] range = xRange;
    for (int i = 0; i < xData.length; i++) {
        xData[i] = (range[0] + (range[1] - range[0]) * (i / (xData.length - 1.f)));
    }

    xData = PlotingToolkit.getXDataFloat(aScan.length);
    updateAScan();

    int pos = (int) getOffset();
    if (pos < 0) {
        pos = 0;
    }
    XYSeriesCollection datCol1 = PlotingToolkit.getCollection(xData, aScan, "Data");

    XYSeriesCollection datCol2 = PlotingToolkit.getCollection(new float[] { xData[pos] },
            new float[] { aScan[pos] }, "Data");

    dataPlot.getXYPlot().setDataset(0, datCol1);
    dataPlot.getXYPlot().setDataset(1, datCol2);

    XYLineAndShapeRenderer dataRender1 = new XYLineAndShapeRenderer(true, false);
    XYLineAndShapeRenderer dataRender2 = new XYLineAndShapeRenderer(false, true);

    dataRender1.setSeriesPaint(0, Color.CYAN);
    dataRender2.setSeriesPaint(0, Color.RED);

    dataPlot.getXYPlot().setRenderer(0, dataRender1);
    dataPlot.getXYPlot().setRenderer(1, dataRender2);

    // XYSeriesCollection datCol1 = PlotingToolkit
    // .getCollection(xData, aScan, "Data");
    //
    // XYLineAndShapeRenderer dataRender1 = new XYLineAndShapeRenderer(true,
    // false);
    //
    // dataRender1.setSeriesPaint(0, Color.CYAN);
    // dataPlot.getXYPlot().setRenderer(0, dataRender1);
    // dataPlot.getXYPlot().setDataset(0, datCol1);

    dataPanel.repaint();
    return true;
}

From source file:de.bund.bfr.knime.pmmlite.views.chart.ChartCreator.java

private List<XYItemRenderer> createStrictRenderers(String id, int n) {
    List<XYItemRenderer> renderers = new ArrayList<>();
    List<Color> colorList = colorLists.containsKey(id) ? colorLists.get(id) : ChartUtils.createColorList(n);
    List<NamedShape> shapeList = shapeLists.containsKey(id) ? shapeLists.get(id)
            : ChartUtils.createShapeList(n);

    for (int i = 0; i < n; i++) {
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(drawLines, true);

        renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
        renderer.setSeriesPaint(0, colorList.get(i));
        renderer.setSeriesShape(0, shapeList.get(i).getShape());
        renderers.add(renderer);/*from   ww  w.  j a  v  a  2s  . c o m*/
    }

    return renderers;
}

From source file:org.matsim.integration.weekly.fundamentaldiagram.CreateAutomatedFDTest.java

private void scatterPlot(Map<Double, Map<String, Tuple<Double, Double>>> inputData, String outFile) {

    String mode1 = travelModes[0];
    XYSeries carFlow = new XYSeries(mode1 + " flow");
    XYSeries carSpeed = new XYSeries(mode1 + " speed");

    XYSeries bikeFlow = null;/*from   w w  w  . j a v  a2s. c o  m*/
    XYSeries bikeSpeed = null;

    if (travelModes.length == 2) {
        bikeFlow = new XYSeries(travelModes[1] + " flow");
        bikeSpeed = new XYSeries(travelModes[1] + " speed");
    }

    for (double d : inputData.keySet()) {
        carFlow.add(d, inputData.get(d).get(mode1).getFirst());
        carSpeed.add(d, inputData.get(d).get(mode1).getSecond());

        if (travelModes.length == 2) {
            bikeFlow.add(d, inputData.get(d).get(travelModes[1]).getFirst());
            bikeSpeed.add(d, inputData.get(d).get(travelModes[1]).getSecond());
        }
    }

    // flow vs density
    XYSeriesCollection flowDataset = new XYSeriesCollection();
    flowDataset.addSeries(carFlow);

    NumberAxis flowAxis = new NumberAxis("Flow (PCU/h)");
    flowAxis.setRange(0.0, 1700.0);

    XYPlot plot1 = new XYPlot(flowDataset, null, flowAxis, new XYLineAndShapeRenderer(false, true));
    plot1.setRangeAxisLocation(AxisLocation.BOTTOM_OR_LEFT);

    // speed vs density
    XYSeriesCollection speedDataset = new XYSeriesCollection();
    speedDataset.addSeries(carSpeed);

    if (travelModes.length == 2) {
        flowDataset.addSeries(bikeFlow);
        speedDataset.addSeries(bikeSpeed);
    }

    NumberAxis speedAxis = new NumberAxis("Speed (m/s)");
    speedAxis.setRange(0.0, 17.0);

    XYPlot plot2 = new XYPlot(speedDataset, null, speedAxis, new XYLineAndShapeRenderer(false, true));
    plot2.setRangeAxisLocation(AxisLocation.TOP_OR_LEFT);

    NumberAxis densityAxis = new NumberAxis("Overall density (PCU/km)");
    densityAxis.setRange(0.0, 140.00);

    CombinedDomainXYPlot plot = new CombinedDomainXYPlot(densityAxis);
    plot.setGap(10.);
    plot.add(plot1);
    plot.add(plot2);
    plot.setOrientation(PlotOrientation.VERTICAL);

    JFreeChart chart = new JFreeChart("Fundamental diagrams", JFreeChart.DEFAULT_TITLE_FONT, plot, true);

    try {
        ChartUtilities.saveChartAsPNG(new File(outFile), chart, 800, 600);
    } catch (IOException e) {
        throw new RuntimeException("Data is not plotted. Reason " + e);
    }
}

From source file:org.orbeon.oxf.processor.serializer.legacy.JFreeChartSerializer.java

protected JFreeChart drawChart(ChartConfig chartConfig, final Dataset ds) {
    JFreeChart chart = null;/*from w  w w . ja  v a 2s.c o m*/
    Axis categoryAxis = null;
    if (ds instanceof XYSeriesCollection) {
        categoryAxis = new RestrictedNumberAxis(chartConfig.getCategoryTitle());
    } else if (ds instanceof TimeSeriesCollection) {
        categoryAxis = new DateAxis(chartConfig.getCategoryTitle());
        ((DateAxis) categoryAxis).setDateFormatOverride(new SimpleDateFormat(chartConfig.getDateFormat()));
        if (chartConfig.getCategoryLabelAngle() == 90) {
            ((DateAxis) categoryAxis).setVerticalTickLabels(true);
        } else {
            if (chartConfig.getCategoryLabelAngle() != 0)
                throw new OXFException(
                        "The only supported values of category-label-angle for time-series charts are 0 or 90");
        }
    } else {
        categoryAxis = new CategoryAxis(chartConfig.getCategoryTitle());
        ((CategoryAxis) categoryAxis).setCategoryLabelPositions(chartConfig.getCategoryLabelPosition());
    }
    NumberAxis valueAxis = new RestrictedNumberAxis(chartConfig.getSerieTitle());
    valueAxis.setAutoRangeIncludesZero(chartConfig.getSerieAutoRangeIncludeZero());
    AbstractRenderer renderer = null;
    Plot plot = null;

    switch (chartConfig.getType()) {
    case ChartConfig.VERTICAL_BAR_TYPE:
    case ChartConfig.HORIZONTAL_BAR_TYPE:
        renderer = (ds instanceof ItemPaintCategoryDataset) ? new BarRenderer() {
            public Paint getItemPaint(int row, int column) {
                Paint p = ((ItemPaintCategoryDataset) ds).getItemPaint(row, column);
                if (p != null)
                    return p;
                else
                    return getSeriesPaint(row);
            }
        } : new BarRenderer();

        plot = new CategoryPlot((CategoryDataset) ds, (CategoryAxis) categoryAxis, (ValueAxis) valueAxis,
                (CategoryItemRenderer) renderer);

        if (chartConfig.getType() == ChartConfig.VERTICAL_BAR_TYPE)
            ((CategoryPlot) plot).setOrientation(PlotOrientation.VERTICAL);
        else
            ((CategoryPlot) plot).setOrientation(PlotOrientation.HORIZONTAL);

        break;
    case ChartConfig.STACKED_VERTICAL_BAR_TYPE:
    case ChartConfig.STACKED_HORIZONTAL_BAR_TYPE:
        renderer = (ds instanceof ItemPaintCategoryDataset) ? new StackedBarRenderer() {
            public Paint getItemPaint(int row, int column) {
                Paint p = ((ItemPaintCategoryDataset) ds).getItemPaint(row, column);
                if (p != null)
                    return p;
                else
                    return getSeriesPaint(row);
            }
        } : new StackedBarRenderer();
        plot = new CategoryPlot((CategoryDataset) ds, (CategoryAxis) categoryAxis, (ValueAxis) valueAxis,
                (CategoryItemRenderer) renderer);

        if (chartConfig.getType() == ChartConfig.STACKED_VERTICAL_BAR_TYPE)
            ((CategoryPlot) plot).setOrientation(PlotOrientation.VERTICAL);
        else
            ((CategoryPlot) plot).setOrientation(PlotOrientation.HORIZONTAL);
        break;
    case ChartConfig.LINE_TYPE:
        renderer = (ds instanceof ItemPaintCategoryDataset) ? new LineAndShapeRenderer(true, false) {
            public Paint getItemPaint(int row, int column) {
                Paint p = ((ItemPaintCategoryDataset) ds).getItemPaint(row, column);
                if (p != null)
                    return p;
                else
                    return getSeriesPaint(row);
            }
        } : (new LineAndShapeRenderer(true, false));
        plot = new CategoryPlot((CategoryDataset) ds, (CategoryAxis) categoryAxis, (ValueAxis) valueAxis,
                (CategoryItemRenderer) renderer);
        ((CategoryPlot) plot).setOrientation(PlotOrientation.VERTICAL);
        break;
    case ChartConfig.AREA_TYPE:
        renderer = (ds instanceof ItemPaintCategoryDataset) ? new AreaRenderer() {
            public Paint getItemPaint(int row, int column) {
                Paint p = ((ItemPaintCategoryDataset) ds).getItemPaint(row, column);
                if (p != null)
                    return p;
                else
                    return getSeriesPaint(row);
            }
        } : new AreaRenderer();
        plot = new CategoryPlot((CategoryDataset) ds, (CategoryAxis) categoryAxis, (ValueAxis) valueAxis,
                (CategoryItemRenderer) renderer);
        ((CategoryPlot) plot).setOrientation(PlotOrientation.VERTICAL);
        break;
    case ChartConfig.VERTICAL_BAR3D_TYPE:
    case ChartConfig.HORIZONTAL_BAR3D_TYPE:
        categoryAxis = new CategoryAxis3D(chartConfig.getCategoryTitle());
        valueAxis = new NumberAxis3D(chartConfig.getSerieTitle());
        renderer = (ds instanceof ItemPaintCategoryDataset) ? new BarRenderer3D() {
            public Paint getItemPaint(int row, int column) {
                Paint p = ((ItemPaintCategoryDataset) ds).getItemPaint(row, column);
                if (p != null)
                    return p;
                else
                    return getSeriesPaint(row);
            }
        } : new BarRenderer3D();
        plot = new CategoryPlot((CategoryDataset) ds, (CategoryAxis) categoryAxis, (ValueAxis) valueAxis,
                (CategoryItemRenderer) renderer);

        if (chartConfig.getType() == ChartConfig.VERTICAL_BAR3D_TYPE)
            ((CategoryPlot) plot).setOrientation(PlotOrientation.VERTICAL);
        else
            ((CategoryPlot) plot).setOrientation(PlotOrientation.HORIZONTAL);

        break;
    case ChartConfig.STACKED_VERTICAL_BAR3D_TYPE:
    case ChartConfig.STACKED_HORIZONTAL_BAR3D_TYPE:
        categoryAxis = new CategoryAxis3D(chartConfig.getCategoryTitle());
        valueAxis = new NumberAxis3D(chartConfig.getSerieTitle());
        renderer = (ds instanceof ItemPaintCategoryDataset) ? new StackedBarRenderer3D() {
            public Paint getItemPaint(int row, int column) {
                Paint p = ((ItemPaintCategoryDataset) ds).getItemPaint(row, column);
                if (p != null)
                    return p;
                else
                    return getSeriesPaint(row);
            }
        } : new StackedBarRenderer3D();
        plot = new CategoryPlot((CategoryDataset) ds, (CategoryAxis) categoryAxis, (ValueAxis) valueAxis,
                (CategoryItemRenderer) renderer);

        if (chartConfig.getType() == ChartConfig.STACKED_VERTICAL_BAR3D_TYPE)
            ((CategoryPlot) plot).setOrientation(PlotOrientation.VERTICAL);
        else
            ((CategoryPlot) plot).setOrientation(PlotOrientation.HORIZONTAL);

        break;
    case ChartConfig.PIE_TYPE:
    case ChartConfig.PIE3D_TYPE:
        categoryAxis = null;
        valueAxis = null;
        renderer = null;
        ExtendedPieDataset pds = (ExtendedPieDataset) ds;

        plot = chartConfig.getType() == ChartConfig.PIE_TYPE ? new PiePlot(pds) : new PiePlot3D(pds);

        PiePlot pp = (PiePlot) plot;
        pp.setLabelGenerator(new StandardPieSectionLabelGenerator());

        for (int i = 0; i < pds.getItemCount(); i++) {
            Paint p = pds.getPaint(i);
            if (p != null)
                pp.setSectionPaint(i, p);

            pp.setExplodePercent(i, pds.getExplodePercent(i));

            Paint paint = pds.getPaint(i);
            if (paint != null)
                pp.setSectionPaint(i, paint);
        }
        break;
    case ChartConfig.XY_LINE_TYPE:
        renderer = new XYLineAndShapeRenderer(true, false);
        plot = new XYPlot((XYDataset) ds, (ValueAxis) categoryAxis, (ValueAxis) valueAxis,
                (XYLineAndShapeRenderer) renderer);
        break;
    case ChartConfig.TIME_SERIES_TYPE:
        renderer = new XYLineAndShapeRenderer(true, false);
        plot = new XYPlot((XYDataset) ds, (DateAxis) categoryAxis, (ValueAxis) valueAxis,
                (XYLineAndShapeRenderer) renderer);
        break;
    default:
        throw new OXFException("Chart Type not supported");
    }

    if (categoryAxis != null) {
        categoryAxis.setLabelPaint(chartConfig.getTitleColor());
        categoryAxis.setTickLabelPaint(chartConfig.getTitleColor());
        categoryAxis.setTickMarkPaint(chartConfig.getTitleColor());
        if (categoryAxis instanceof RestrictedNumberAxis) {
            ((RestrictedNumberAxis) categoryAxis).setMaxTicks(chartConfig.getMaxNumOfLabels());
        }
        if (categoryAxis instanceof CategoryAxis && chartConfig.getCategoryMargin() != 0)
            ((CategoryAxis) categoryAxis).setCategoryMargin(chartConfig.getCategoryMargin());
    }

    if (valueAxis != null) {
        valueAxis.setLabelPaint(chartConfig.getTitleColor());
        valueAxis.setTickLabelPaint(chartConfig.getTitleColor());
        valueAxis.setTickMarkPaint(chartConfig.getTitleColor());
        ((RestrictedNumberAxis) valueAxis).setMaxTicks(chartConfig.getMaxNumOfLabels());
    }

    if (renderer != null) {
        if (renderer instanceof XYLineAndShapeRenderer) {
            ((XYLineAndShapeRenderer) renderer).setBaseItemLabelGenerator(new StandardXYItemLabelGenerator());
        } else {
            ((CategoryItemRenderer) renderer)
                    .setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator());
        }
        if (renderer instanceof BarRenderer)
            ((BarRenderer) renderer).setItemMargin(chartConfig.getBarMargin());

        int j = 0;
        for (Iterator i = chartConfig.getValueIterator(); i.hasNext();) {
            Value v = (Value) i.next();
            renderer.setSeriesPaint(j, v.getColor());
            j++;
        }
    }

    plot.setOutlinePaint(chartConfig.getTitleColor());
    CustomLegend legend = chartConfig.getLegendConfig();
    chart = new JFreeChart(chartConfig.getTitle(), TextTitle.DEFAULT_FONT, plot, false);
    if (legend.isVisible()) {
        legend.setSources(new LegendItemSource[] { plot });
        chart.addLegend(legend);
    }
    chart.setBackgroundPaint(chartConfig.getBackgroundColor());
    TextTitle textTitle = new TextTitle(chartConfig.getTitle(), TextTitle.DEFAULT_FONT,
            chartConfig.getTitleColor(), TextTitle.DEFAULT_POSITION, TextTitle.DEFAULT_HORIZONTAL_ALIGNMENT,
            TextTitle.DEFAULT_VERTICAL_ALIGNMENT, TextTitle.DEFAULT_PADDING);
    chart.setTitle(textTitle);
    return chart;
}

From source file:de.bund.bfr.knime.pmm.common.chart.ChartCreator.java

private void plotFunction(XYPlot plot, Plotable plotable, String id, Color defaultColor, Shape defaultShape,
        double minX, double maxX) throws ConvertException {
    double[][] points = plotable.getFunctionPoints(paramX, paramY, unitX, unitY, transformX, transformY, minX,
            maxX, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
    double[][] functionErrors = null;
    String legend = shortLegend.get(id);
    Color color = colors.get(id);
    Shape shape = shapes.get(id);

    if (showConfidenceInterval) {
        functionErrors = plotable.getFunctionErrors(paramX, paramY, unitX, unitY, transformX, transformY, minX,
                maxX, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
    }/*  w w  w .ja  va2  s .  c  o m*/

    if (addInfoInLegend) {
        legend = longLegend.get(id);
    }

    if (color == null) {
        color = defaultColor;
    }

    if (shape == null) {
        shape = defaultShape;
    }

    if (points != null) {
        int i;

        if (plot.getDataset(0) == null) {
            i = 0;
        } else {
            i = plot.getDatasetCount();
        }

        if (functionErrors != null) {
            YIntervalSeriesCollection functionDataset = new YIntervalSeriesCollection();
            DeviationRenderer functionRenderer = new DeviationRenderer(true, false);
            YIntervalSeries series = new YIntervalSeries(legend);

            for (int j = 0; j < points[0].length; j++) {
                double error = Double.isNaN(functionErrors[1][j]) ? 0.0 : functionErrors[1][j];

                series.add(points[0][j], points[1][j], points[1][j] - error, points[1][j] + error);
            }

            functionDataset.addSeries(series);
            functionRenderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
            functionRenderer.setSeriesPaint(0, color);
            functionRenderer.setSeriesFillPaint(0, color);
            functionRenderer.setSeriesShape(0, shape);

            plot.setDataset(i, functionDataset);
            plot.setRenderer(i, functionRenderer);
        } else {
            DefaultXYDataset functionDataset = new DefaultXYDataset();
            XYLineAndShapeRenderer functionRenderer = new XYLineAndShapeRenderer(true, false);

            functionDataset.addSeries(legend, points);
            functionRenderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
            functionRenderer.setSeriesPaint(0, color);
            functionRenderer.setSeriesShape(0, shape);

            plot.setDataset(i, functionDataset);
            plot.setRenderer(i, functionRenderer);
        }
    }
}

From source file:weka.gui.beans.JFreeChartOffscreenChartRenderer.java

/**
 * Render an XY scatter plot/*from   w  ww.  j  ava2s  .  c o m*/
 * 
 * @param width the width of the resulting chart in pixels
 * @param height the height of the resulting chart in pixels
 * @param series a list of Instances - one for each series to be plotted
 * @param xAxis the name of the attribute for the x-axis (all series Instances
 *          are expected to have an attribute of the same type with this name)
 * @param yAxis the name of the attribute for the y-axis (all series Instances
 *          are expected to have an attribute of the same type with this name)
 * @param optionalArgs optional arguments to the renderer (may be null)
 * 
 * @return a BufferedImage containing the chart
 * @throws Exception if there is a problem rendering the chart
 */
public BufferedImage renderXYScatterPlot(int width, int height, List<Instances> series, String xAxis,
        String yAxis, List<String> optionalArgs) throws Exception {

    String plotTitle = "Scatter Plot";
    String userTitle = getOption(optionalArgs, "-title");
    plotTitle = (userTitle != null) ? userTitle : plotTitle;
    String colorAtt = getOption(optionalArgs, "-color");

    if (series.size() == 1 && colorAtt != null && colorAtt.length() > 0) {
        int colIndex = getIndexOfAttribute(series.get(0), colorAtt);
        if (colIndex >= 0 && series.get(0).attribute(colIndex).isNominal()) {
            // split single series out into multiple instances objects - one
            // per class
            series = splitToClasses(series.get(0), colIndex);
            for (Instances insts : series) {
                insts.setClassIndex(colIndex);
            }
        }
    }

    Instances masterInstances = series.get(0);
    int xAx = getIndexOfAttribute(masterInstances, xAxis);
    int yAx = getIndexOfAttribute(masterInstances, yAxis);
    if (xAx < 0) {
        xAx = 0;
    }
    if (yAx < 0) {
        yAx = 0;
    }

    // Set the axis names just in case we've been supplied with
    // /first, /last or /<num>
    xAxis = masterInstances.attribute(xAx).name();
    yAxis = masterInstances.attribute(yAx).name();

    // look for an additional attribute that stores the
    // shape sizes - could be either nominal or numeric errors.
    // We only use numeric error information
    String shapeSize = getOption(optionalArgs, "-shapeSize");

    boolean nominalClass = (masterInstances.classIndex() >= 0 && masterInstances.classAttribute().isNominal());

    int shapeSizeI = -1;
    if (shapeSize != null && shapeSize.length() > 0) {
        shapeSizeI = getIndexOfAttribute(masterInstances, shapeSize);
    }

    AbstractIntervalXYDataset xyDataset = null;

    if (shapeSizeI < 0 || nominalClass) {
        xyDataset = new XYSeriesCollection();
    } else {
        xyDataset = new XYIntervalSeriesCollection();
    }
    // add master series
    Series master = null;

    if (shapeSizeI < 0 || nominalClass) {
        master = new XYSeries(masterInstances.relationName());
    } else {
        master = new XYIntervalSeries(masterInstances.relationName());
    }
    AttributeStats xStats = masterInstances.attributeStats(xAx);
    AttributeStats yStats = masterInstances.attributeStats(yAx);
    double sizeRange = 0;
    double sizeMin = 0;
    if (shapeSizeI >= 0 && !nominalClass) {
        AttributeStats sStats = masterInstances.attributeStats(shapeSizeI);
        sizeRange = sStats.numericStats.max - sStats.numericStats.min;
        sizeMin = sStats.numericStats.min;
    }
    double xRange = 0;
    if (masterInstances.attribute(xAx).isNominal()) {
        xRange = masterInstances.attribute(xAx).numValues();
    } else {
        xRange = xStats.numericStats.max - xStats.numericStats.min;
    }
    double yRange = 0;
    if (masterInstances.attribute(yAx).isNominal()) {
        xRange = masterInstances.attribute(yAx).numValues();
    } else {
        yRange = yStats.numericStats.max - yStats.numericStats.min;
    }
    for (int i = 0; i < masterInstances.numInstances(); i++) {
        Instance inst = masterInstances.instance(i);
        if (!inst.isMissing(xAx) && !inst.isMissing(yAx)) {
            if (shapeSizeI < 0 || nominalClass) {
                ((XYSeries) master).add(inst.value(xAx), inst.value(yAx));
            } else {
                double xBar = (inst.value(shapeSizeI) - sizeMin) / sizeRange;
                xBar *= (xRange / 5.0); // max of 1/5th the x range
                double yBar = (inst.value(shapeSizeI) - sizeMin) / sizeRange;
                yBar *= (yRange / 5.0);
                double x = inst.value(xAx);
                double y = inst.value(yAx);
                ((XYIntervalSeries) master).add(x, x - (xBar / 2.0), x + (xBar / 2.0), y, y - (yBar / 2.0),
                        y + (yBar / 2.0));
            }
        }
    }

    if (shapeSizeI < 0 || nominalClass) {
        ((XYSeriesCollection) xyDataset).addSeries((XYSeries) master);
    } else {
        ((XYIntervalSeriesCollection) xyDataset).addSeries((XYIntervalSeries) master);
    }

    // remaining series
    for (int i = 1; i < series.size(); i++) {
        Instances aSeriesI = series.get(i);
        Series aSeriesJ = null;
        if (shapeSizeI < 0 || nominalClass) {
            aSeriesJ = new XYSeries(aSeriesI.relationName());
        } else {
            aSeriesJ = new XYIntervalSeries(aSeriesI.relationName());
        }
        for (int j = 0; j < aSeriesI.numInstances(); j++) {
            Instance inst = aSeriesI.instance(j);
            if (!inst.isMissing(xAx) && !inst.isMissing(yAx)) {
                if (shapeSizeI < 0 || nominalClass) {
                    ((XYSeries) aSeriesJ).add(inst.value(xAx), inst.value(yAx));
                } else {
                    double xBar = (inst.value(shapeSizeI) - sizeMin) / sizeRange;
                    xBar *= (xRange / 5.0); // max of 1/10th the x range
                    double yBar = (inst.value(shapeSizeI) - sizeMin) / sizeRange;
                    yBar *= (yRange / 5.0);
                    double x = inst.value(xAx);
                    double y = inst.value(yAx);
                    ((XYIntervalSeries) aSeriesJ).add(x, x - (xBar / 2.0), x + (xBar / 2.0), y,
                            y - (yBar / 2.0), y + (yBar / 2.0));
                }
            }
        }

        if (shapeSizeI < 0 || nominalClass) {
            ((XYSeriesCollection) xyDataset).addSeries((XYSeries) aSeriesJ);
        } else {
            ((XYIntervalSeriesCollection) xyDataset).addSeries((XYIntervalSeries) aSeriesJ);
        }
    }

    JFreeChart chart = ChartFactory.createXYLineChart(plotTitle, xAxis, yAxis, xyDataset,
            PlotOrientation.VERTICAL, true, false, false);
    chart.setBackgroundPaint(java.awt.Color.white);
    XYPlot plot = (XYPlot) chart.getPlot();
    if (shapeSizeI < 0 || nominalClass) {
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(false, true);
        renderer.setBaseShapesFilled(false);
        plot.setRenderer(renderer);
    } else {
        XYErrorRenderer renderer = new XYErrorRenderer();
        renderer.setDrawXError(true);
        renderer.setDrawYError(true);
        renderer.setBaseLinesVisible(false);
        plot.setRenderer(renderer);
    }

    BufferedImage image = chart.createBufferedImage(width, height);

    return image;
}

From source file:org.jfree.eastwood.ChartEngine.java

/**
 * The 'ewtr' tag is an Eastwood extension that draws a trend line over a
 * chart, using data that has been added to a secondary dataset using the
 * 'ewd2' tag.//www  . j  a  va2 s  .  c o  m
 *
 * @param params  the chart parameters;
 * @param chart  the chart under construction (will be updated by this
 *         method if necessary).
 */
public static void processEWTR(Map params, JFreeChart chart) {
    // the 'ewtr' arguments are:
    // - <seriesIndex> : the index of the series in the secondary dataset;
    // - <colour> : the colour;
    // - <lineThickness> : the line thickness;
    String[] ewtrStr = (String[]) params.get("ewtr");
    if (ewtrStr != null) {
        String[] atts = ewtrStr[0].split(",");
        int series = Integer.parseInt(atts[0]);
        Color color = parseColor(atts[1]);
        float lineWidth = Float.parseFloat(atts[2]);
        Plot plot = chart.getPlot();
        if (plot instanceof CategoryPlot) {
            CategoryPlot cp = (CategoryPlot) plot;
            if (cp.getDataset(1) != null) {
                LineAndShapeRenderer r = new LineAndShapeRenderer(true, false);
                r.setBaseSeriesVisible(false);
                r.setSeriesVisible(series, Boolean.TRUE);
                r.setSeriesPaint(series, color);
                r.setSeriesStroke(series, new BasicStroke(lineWidth));
                cp.setRenderer(1, r);

                cp.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
            }
        } else if (plot instanceof XYPlot) {
            XYPlot xp = (XYPlot) plot;
            if (xp.getDataset(1) != null) {
                XYLineAndShapeRenderer r = new XYLineAndShapeRenderer(true, false);
                r.setBaseSeriesVisible(false);
                r.setSeriesVisible(series, Boolean.TRUE);
                r.setSeriesPaint(series, color);
                r.setSeriesStroke(series, new BasicStroke(lineWidth));
                xp.setRenderer(1, r);
                xp.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
            }
        }
    }

}

From source file:de.bund.bfr.knime.pmmlite.views.chart.ChartCreator.java

private List<XYItemRenderer> createStrictFunctionRenderers(String id, List<XYDataset> dataSets) {
    List<XYItemRenderer> renderers = new ArrayList<>();
    List<Color> colorList = colorLists.get(id);
    List<NamedShape> shapeList = shapeLists.get(id);

    if (colorList == null || colorList.isEmpty()) {
        colorList = ChartUtils.createColorList(dataSets.size());
    }/* w  w w .  ja  v  a2 s  .co  m*/

    if (shapeList == null || shapeList.isEmpty()) {
        shapeList = ChartUtils.createShapeList(dataSets.size());
    }

    for (int i = 0; i < dataSets.size(); i++) {
        if (dataSets.get(i) instanceof YIntervalSeriesCollection) {
            DeviationRenderer renderer = new DeviationRenderer(true, false);

            renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
            renderer.setSeriesPaint(0, colorList.get(i));
            renderer.setSeriesFillPaint(0, colorList.get(i));
            renderer.setSeriesShape(0, shapeList.get(i).getShape());

            renderers.add(renderer);
        } else {
            XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);

            renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
            renderer.setSeriesPaint(0, colorList.get(i));
            renderer.setSeriesShape(0, shapeList.get(i).getShape());

            renderers.add(renderer);
        }
    }

    return renderers;
}

From source file:org.operamasks.faces.render.graph.ChartRenderer.java

protected void createCurveSeries(JFreeChart chart, UIChart comp) {
    UIDataSeries data = comp.getDataSeries();
    if (data == null) {
        return;//  w ww  .jav  a  2s  . c om
    }

    if (!(chart.getPlot() instanceof XYPlot)) {
        return;
    }

    XYPlot plot = (XYPlot) chart.getPlot();
    XYDataset dataset = plot.getDataset();
    if (dataset.getSeriesCount() == 0) {
        return;
    }

    UIDataItem[] items = data.getItems();
    XYSeriesCollection collection = null;
    XYLineAndShapeRenderer renderer = null;

    int curSeries = 0;
    for (int i = 0; i < items.length; i++) {
        if (dataset.getItemCount(i) < 2) {
            continue;
        }

        for (UIComponent kid : items[i].getChildren()) {
            if (kid.isRendered() && (kid instanceof UICurve)) {
                UICurve curve = (UICurve) kid;
                XYSeries series = createCurveSeries(curve, dataset, i);

                if (collection == null) {
                    collection = new XYSeriesCollection();
                    renderer = new XYLineAndShapeRenderer(true, false);
                }
                collection.addSeries(series);

                String legend = curve.getLegend();
                if (legend == null || legend.length() == 0) {
                    renderer.setSeriesVisibleInLegend(curSeries, false);
                }

                Paint color = curve.getColor();
                if (color != null) {
                    renderer.setSeriesPaint(curSeries, color);
                }

                curSeries++;
            }
        }
    }

    if (collection != null) {
        plot.setDataset(1, collection);
        plot.setRenderer(1, renderer);
    }
}