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

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

Introduction

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

Prototype

public void setSeriesPaint(int series, Paint paint) 

Source Link

Document

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

Usage

From source file:it.eng.spagobi.engines.chart.bo.charttypes.targetcharts.SparkLine.java

private void addPointSeries(TimeSeries series, XYPlot plot) {
    logger.debug("IN");
    TimeSeries pointSerie = new TimeSeries("Point", Month.class);
    for (int i = 0; i < series.getItemCount(); i++) {
        pointSerie.add(series.getTimePeriod(i), series.getValue(i));
    }/*w  ww.j  ava  2 s .c o m*/
    final TimeSeriesCollection avgDs = new TimeSeriesCollection(pointSerie);

    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false) {
        public boolean getItemShapeVisible(int _series, int item) {
            return (true);
        }
    };
    renderer.setSeriesPaint(2, Color.LIGHT_GRAY);
    renderer.setBaseShapesVisible(true);
    renderer.setBaseShapesFilled(true);
    renderer.setDrawOutlines(true);
    renderer.setUseFillPaint(true);
    renderer.setBaseFillPaint(Color.BLACK);
    renderer.setBaseOutlinePaint(Color.BLACK);
    renderer.setUseOutlinePaint(true);
    renderer.setSeriesShape(0, new Ellipse2D.Double(-2.0, -2.0, 4.0, 4.0));

    plot.setDataset(2, avgDs);
    plot.setRenderer(2, renderer);
    logger.debug("OUT");

}

From source file:net.nosleep.superanalyzer.analysis.views.LikesView.java

private void createChart() {
    _chart = ChartFactory.createScatterPlot(Misc.getString("LIKES_VS_PLAYS"),
            Misc.getString("ALBUM_PLAY_COUNT"), Misc.getString("ALBUM_RATING"), _dataset,
            PlotOrientation.VERTICAL, false, true, false);

    _chart.addSubtitle(HomePanel.createSubtitle(Misc.getString("LIKES_VS_PLAYS_SUBTITLE")));

    XYPlot plot = (XYPlot) _chart.getPlot();

    ChartUtilities.applyCurrentTheme(_chart);

    plot.setDomainPannable(true);//w  w w .j a  v  a  2  s. c  o m
    plot.setRangePannable(true);
    plot.setDomainZeroBaselineVisible(true);
    plot.setRangeZeroBaselineVisible(true);

    plot.setDomainGridlinesVisible(false);
    plot.setRangeGridlinesVisible(false);

    // get rid of the little line above/next to the axis
    plot.setDomainZeroBaselinePaint(Color.white);
    plot.setRangeZeroBaselinePaint(Color.white);

    /*
     * NumberAxis domainAxis = (NumberAxis) plot.getDomainAxis();
     * domainAxis.setAutoRangeIncludesZero(false);
     * 
     * domainAxis.setTickMarkInsideLength(2.0f);
     * domainAxis.setTickMarkOutsideLength(2.0f);
     * 
     * domainAxis.setMinorTickCount(2);
     * domainAxis.setMinorTickMarksVisible(true);
     */
    NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    /*
     * rangeAxis.setTickMarkInsideLength(2.0f);
     * rangeAxis.setTickMarkOutsideLength(2.0f);
     * rangeAxis.setMinorTickCount(2);
     * rangeAxis.setMinorTickMarksVisible(true);
     */
    rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());

    NumberAxis domainAxis = (NumberAxis) plot.getDomainAxis();
    domainAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());

    // format the line renderer after applying the theme
    XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) plot.getRenderer();

    renderer.setBaseShapesVisible(true);
    renderer.setDrawOutlines(true);
    renderer.setUseFillPaint(true);
    renderer.setBaseFillPaint(Color.white);
    renderer.setSeriesStroke(0, new BasicStroke(3.0f));
    renderer.setSeriesOutlineStroke(0, new BasicStroke(2.0f));
    renderer.setSeriesShape(0, new Ellipse2D.Double(-4.0, -4.0, 8.0, 8.0));

    Misc.formatChart(plot);
    renderer.setSeriesPaint(0, Theme.getColorSet()[1]);

}

From source file:tools.descartes.bungee.chart.ChartGenerator.java

private static XYPlot createAllocationPlot(final TimeSeriesCollection dataset) {

    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
    renderer.setBaseShapesVisible(true);
    renderer.setBaseShapesFilled(false);
    final NumberAxis rangeAxis = new NumberAxis("Resource Amount");
    rangeAxis.setAutoRangeIncludesZero(true);
    //rangeAxis.setTickUnit(new NumberTickUnit(1));
    double lower = Math.min(1, dataset.getRangeBounds(false).getLowerBound()) - 0.2;
    double upper = Math.max(2, dataset.getRangeBounds(false).getUpperBound()) + 0.2;
    rangeAxis.setRange(lower, upper);/* ww  w.  j  a v  a  2  s.  c o m*/
    final XYPlot allocationPlot = new XYPlot(dataset, null, rangeAxis, renderer);
    allocationPlot.setSeriesRenderingOrder(SeriesRenderingOrder.REVERSE);

    for (int i = 0; i < dataset.getSeriesCount(); i++) {
        TimeSeries series = dataset.getSeries(i);
        //addEndSeriesItem(lastDate, series);
        String description = series.getKey().toString();
        renderer.setSeriesStroke(i, new BasicStroke(STROKE_WIDTH));
        if (description.equals(AllocationSeries.CATEGORY.DEMAND.toString())) {
            renderer.setSeriesShapesVisible(i, false);
            renderer.setSeriesPaint(i, Color.RED);
        } else if (description.equals(SupplySeries.TYPE.VM_SCHEDULED.toString())) {
            renderer.setSeriesPaint(i, VARIANT_C_COLOR);
        } else if (description.equals(SupplySeries.TYPE.VM_COMPLETED.toString())) {
            renderer.setSeriesPaint(i, VARIANT_B_COLOR);
        } else if (description.equals(SupplySeries.TYPE.LB_RULE_ADAPTION.toString())) {
            if (dataset.getSeriesCount() != 2) {
                renderer.setSeriesPaint(i, VARIANT_A_COLOR);
            } else {
                renderer.setSeriesPaint(i, Color.BLUE);
            }
        } else if (description.equals(SupplySeries.TYPE.MONITORED.toString())) {
            if (dataset.getSeriesCount() != 2) {
                renderer.setSeriesPaint(i, VARIANT_D_COLOR);
            } else {
                renderer.setSeriesPaint(i, Color.BLUE);
            }
        } else {
            renderer.setSeriesPaint(i, colorForConfig(description));
        }
    }

    return allocationPlot;
}

From source file:com.itemanalysis.jmetrik.swing.GraphPanel.java

/**
 * This method should be called after a chart dataset is updated. It
 * will iterate over all XYDatasets and provide the line color and lineStyle.
 * If it is called before a chart has a dataset, it will not have an effect.
 *
 * @param plot/*from   ww  w  . j  a  v a  2s .c om*/
 */
public void setXYPlotRenderer(XYPlot plot) {
    XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) plot.getRenderer();
    int n = plot.getSeriesCount();

    for (int i = 0; i < n; i++) {
        Stroke stroke = new BasicStroke(lineWidth, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10.0f,
                getLineStyle(i), 0.0f);
        renderer.setSeriesStroke(i, stroke);
        renderer.setSeriesPaint(i, getPaintColor(i));
    }
    renderer.setLegendLine(new Line2D.Double(0, 5, 40, 5));
    renderer.setBaseShapesFilled(false);
    renderer.setBaseShapesVisible(showMarkers);
    renderer.setDrawSeriesLineAsPath(true);
    plot.setBackgroundPaint(Color.WHITE);
    plot.setRangeGridlinePaint(Color.LIGHT_GRAY);
    plot.setDomainGridlinePaint(Color.LIGHT_GRAY);
    plot.setRenderer(renderer);
}

From source file:com.att.aro.ui.view.diagnostictab.plot.VideoChunksPlot.java

@Override
public void populate(XYPlot plot, AROTraceData analysis) {
    if (analysis != null) {
        VideoUsage videousage = analysis.getAnalyzerResult().getVideoUsage();
        if (!isReDraw) {
            boPlot.clearPlot(this.bufferOccupancyPlot);
            boTimePlot.clearPlot(this.bufferTimePlot);
            analysis.getAnalyzerResult().setBufferTimeResult(null);
            analysis.getAnalyzerResult().setBufferOccupancyResult(null);
        }//from   www . j a  v a 2s . c  o m

        videoChunksData.removeAllSeries();
        for (XYSeriesCollection seriesColl : startUpDelayCollection) {
            seriesColl.removeAllSeries();
        }

        startUpDelayCollection.clear();
        imgSeries = new ArrayList<BufferedImage>();

        // create the dataset...
        int index = 0;

        series = new XYSeries("Chunks");
        seriesDataSets = new TreeMap<>();
        seriesDataSets = videoChunkPlotter.populateDataSet(analysis.getAnalyzerResult().getVideoUsage());

        imgSeries = videoChunkPlotter.getImageSeries();
        filteredChunks = videousage.getFilteredSegments();
        segmentsToBePlayed.clear();
        if (videousage.getAllSegments() != null) {
            for (VideoEvent ve : videousage.getAllSegments()) {
                segmentsToBePlayed.add(ve);
            }
        }
        for (double timeStamp : seriesDataSets.values()) {
            series.add(timeStamp, 0);
        }

        XYSeriesCollection playTimeStartSeries;
        int first = 0;

        List<VideoEvent> chunkPlayBackTimeList = new ArrayList<VideoEvent>(chunkPlayTime.keySet());
        Collections.sort(chunkPlayBackTimeList, new VideoEventComparator(SortSelection.SEGMENT));
        for (VideoEvent ve : chunkPlayBackTimeList) {

            playTimeStartSeries = new XYSeriesCollection();

            seriesStartUpDelay = new XYSeries("StartUpDelay" + (index++));
            seriesStartUpDelay.add(ve.getDLTimeStamp(), 0);
            seriesStartUpDelay.add((double) chunkPlayTime.get(ve), 0);

            if (first == 0) {
                VideoUsage videoUsage = analysis.getAnalyzerResult().getVideoUsage();
                TreeMap<Double, AROManifest> videoEventList = videoUsage.getAroManifestMap();

                setDelayAROManifest((double) chunkPlayTime.get(ve) - ve.getEndTS(), videoEventList.values());//Set start up delay in AROManifest getDLTimeStamp()

            }
            playTimeStartSeries.addSeries(seriesStartUpDelay);

            startUpDelayCollection.add(playTimeStartSeries);
            first++;
        }

        videoChunksData.addSeries(series);

        VideoChunckImageRenderer renderer = new VideoChunckImageRenderer();
        XYLineAndShapeRenderer rendererDelay = new XYLineAndShapeRenderer();
        for (int i = 0; i < startUpDelayCollection.size(); i++) {
            rendererDelay.setSeriesStroke(i, new BasicStroke(1.0f));
            rendererDelay.setSeriesPaint(i, Color.red);
        }

        XYToolTipGenerator xyToolTipGenerator = new XYToolTipGenerator() {
            @Override
            public String generateToolTip(XYDataset dataset, int series, int item) {
                StringBuffer tooltipValue = new StringBuffer();
                VideoEvent currentVEvent = segmentsToBePlayed.get(item);

                DecimalFormat decimalFormat = new DecimalFormat("0.##");

                tooltipValue.append(decimalFormat.format(currentVEvent.getSegment()) + ","
                        + String.format("%.2f", currentVEvent.getStartTS()) + ","
                        + String.format("%.2f", currentVEvent.getEndTS()) + ",");

                if (!chunkPlayTime.isEmpty()) {
                    if (videoChunkPlotter.getSegmentPlayStartTime(currentVEvent) == -1) {
                        tooltipValue.append("- ,");
                    } else {
                        tooltipValue.append(
                                String.format("%.2f", videoChunkPlotter.getSegmentPlayStartTime(currentVEvent))
                                        + " s,");
                    }
                } else {
                    tooltipValue.append("- ,");
                }
                tooltipValue.append(currentVEvent.getTotalBytes() / 1000); //Converting to KB
                String[] value = tooltipValue.toString().split(",");
                return (MessageFormat.format(VIDEOCHUNK_TOOLTIP, value[0], value[1], value[2], value[3],
                        value[4]));

            }

        };

        renderer.setBaseToolTipGenerator(xyToolTipGenerator);
        renderer.setSeriesShape(0, shape);

        plot.setRenderer(index, renderer);
        for (int i = 0; i < startUpDelayCollection.size(); i++)
            plot.setRenderer(i, rendererDelay);
    }
    isReDraw = false;
    int seriesIndex = 0;
    for (XYSeriesCollection seriesColl : startUpDelayCollection) {
        plot.setDataset(seriesIndex, seriesColl);
        seriesIndex++;
    }

    plot.setDataset(seriesIndex, videoChunksData);
}

From source file:iDynoOptimizer.MOEAFramework26.src.org.moeaframework.analysis.diagnostics.LinePlot.java

@Override
protected void update() {
    XYDataset dataset = null;/*ww  w .  j  av  a 2 s .c om*/

    //generate the plot data
    if (controller.getShowIndividualTraces()) {
        dataset = new DefaultTableXYDataset();

        for (ResultKey key : frame.getSelectedResults()) {
            generateIndividualSeries(key, (DefaultTableXYDataset) dataset);
        }
    } else {
        dataset = new YIntervalSeriesCollection();

        for (ResultKey key : frame.getSelectedResults()) {
            generateQuantileSeries(key, (YIntervalSeriesCollection) dataset);
        }
    }

    //create the chart
    JFreeChart chart = ChartFactory.createXYLineChart(metric, localization.getString("text.NFE"),
            localization.getString("text.value"), dataset, PlotOrientation.VERTICAL, false, true, false);
    final XYPlot plot = chart.getXYPlot();

    //setup the series renderer
    if (controller.getShowIndividualTraces()) {
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);

        for (int i = 0; i < dataset.getSeriesCount(); i++) {
            Paint paint = frame.getPaintHelper().get(dataset.getSeriesKey(i));

            renderer.setSeriesStroke(i, new BasicStroke(1f, 1, 1));
            renderer.setSeriesPaint(i, paint);
        }

        plot.setRenderer(renderer);
    } else {
        DeviationRenderer renderer = new DeviationRenderer(true, false);

        for (int i = 0; i < dataset.getSeriesCount(); i++) {
            Paint paint = frame.getPaintHelper().get(dataset.getSeriesKey(i));

            renderer.setSeriesStroke(i, new BasicStroke(3f, 1, 1));
            renderer.setSeriesPaint(i, paint);
            renderer.setSeriesFillPaint(i, paint);
        }

        plot.setRenderer(renderer);
    }

    //create the legend
    final LegendItemCollection items = plot.getLegendItems();
    Iterator<?> iterator = items.iterator();
    Set<ResultKey> uniqueKeys = new HashSet<ResultKey>();

    while (iterator.hasNext()) {
        LegendItem item = (LegendItem) iterator.next();

        if (uniqueKeys.contains(item.getSeriesKey())) {
            iterator.remove();
        } else {
            uniqueKeys.add((ResultKey) item.getSeriesKey());
        }
    }

    LegendItemSource source = new LegendItemSource() {

        @Override
        public LegendItemCollection getLegendItems() {
            return items;
        }

    };

    LegendTitle legend = new LegendTitle(source);
    legend.setMargin(new RectangleInsets(1.0, 1.0, 1.0, 1.0));
    legend.setFrame(new LineBorder());
    legend.setBackgroundPaint(Color.WHITE);
    legend.setPosition(RectangleEdge.BOTTOM);
    chart.addLegend(legend);

    //scale the axes
    final NumberAxis domainAxis = new NumberAxis();
    domainAxis.setAutoRange(true);
    plot.setDomainAxis(domainAxis);

    //add overlay
    if (controller.getShowLastTrace() && !controller.getShowIndividualTraces()
            && (controller.getLastAccumulator() != null)
            && controller.getLastAccumulator().keySet().contains(metric)) {
        DefaultTableXYDataset dataset2 = new DefaultTableXYDataset();
        XYSeries series = new XYSeries(localization.getString("text.last"), false, false);

        for (int i = 0; i < controller.getLastAccumulator().size(metric); i++) {
            series.add((Number) controller.getLastAccumulator().get("NFE", i),
                    (Number) controller.getLastAccumulator().get(metric, i));
        }

        dataset2.addSeries(series);

        XYLineAndShapeRenderer renderer2 = new XYLineAndShapeRenderer(true, false);
        renderer2.setSeriesStroke(0, new BasicStroke(1f, 1, 1));
        renderer2.setSeriesPaint(0, Color.BLACK);

        plot.setDataset(1, dataset2);
        plot.setRenderer(1, renderer2);
        plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
    }

    //update the chart in the GUI
    removeAll();
    add(new ChartPanel(chart), BorderLayout.CENTER);
    revalidate();
    repaint();
}

From source file:org.gwaspi.gui.reports.SampleQAHetzygPlotZoom.java

private JFreeChart createChart(XYDataset dataset) {
    JFreeChart chart = ChartFactory.createScatterPlot("Heterozygosity vs. Missing Ratio",
            "Heterozygosity Ratio", "Missing Ratio", dataset, PlotOrientation.VERTICAL, true, false, false);

    XYPlot plot = (XYPlot) chart.getPlot();
    plot.setNoDataMessage("NO DATA");
    plot.setDomainZeroBaselineVisible(true);
    plot.setRangeZeroBaselineVisible(true);

    // CHART BACKGROUD COLOR
    chart.setBackgroundPaint(Color.getHSBColor(0.1f, 0.1f, 1.0f)); // Hue, saturation, brightness
    plot.setBackgroundPaint(PLOT_MANHATTAN_BACKGROUND); // Hue, saturation, brightness 9

    // GRIDLINES//from w  ww.  j a va 2s  .c om
    plot.setDomainGridlineStroke(new BasicStroke(0.0f));
    plot.setDomainMinorGridlineStroke(new BasicStroke(0.0f));
    plot.setDomainGridlinePaint(PLOT_MANHATTAN_BACKGROUND.darker().darker()); // Hue, saturation, brightness 7
    plot.setDomainMinorGridlinePaint(PLOT_MANHATTAN_BACKGROUND); // Hue, saturation, brightness 9
    plot.setRangeGridlineStroke(new BasicStroke(0.0f));
    plot.setRangeMinorGridlineStroke(new BasicStroke(0.0f));
    plot.setRangeGridlinePaint(PLOT_MANHATTAN_BACKGROUND.darker().darker()); // Hue, saturation, brightness 7
    plot.setRangeMinorGridlinePaint(PLOT_MANHATTAN_BACKGROUND.darker()); // Hue, saturation, brightness 8

    plot.setDomainMinorGridlinesVisible(true);
    plot.setRangeMinorGridlinesVisible(true);

    // DOTS RENDERER
    XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) plot.getRenderer();
    renderer.setSeriesPaint(0, PLOT_MANHATTAN_DOTS);
    //      renderer.setSeriesOutlinePaint(0, Color.DARK_GRAY);
    //      renderer.setUseOutlinePaint(true);
    // Set dot shape of the currently appended Series
    renderer.setSeriesShape(0, new Rectangle2D.Double(-1, -1, 2, 2));

    renderer.setSeriesVisibleInLegend(0, false);

    // AXIS
    double maxHetzy = 0.005;
    for (int i = 0; i < dataset.getItemCount(0); i++) {
        if (maxHetzy < dataset.getXValue(0, i)) {
            maxHetzy = dataset.getXValue(0, i);
        }
    }
    NumberAxis hetzyAxis = (NumberAxis) plot.getDomainAxis();
    hetzyAxis.setAutoRangeIncludesZero(true);
    hetzyAxis.setAxisLineVisible(true);
    hetzyAxis.setTickLabelsVisible(true);
    hetzyAxis.setTickMarksVisible(true);
    hetzyAxis.setRange(0, maxHetzy * 1.1);

    double maxMissrat = 0.005;
    for (int i = 0; i < dataset.getItemCount(0); i++) {
        if (maxMissrat < dataset.getYValue(0, i)) {
            maxMissrat = dataset.getYValue(0, i);
        }
    }
    NumberAxis missratAxis = (NumberAxis) plot.getRangeAxis();
    missratAxis.setAutoRangeIncludesZero(true);
    missratAxis.setAxisLineVisible(true);
    missratAxis.setTickLabelsVisible(true);
    missratAxis.setTickMarksVisible(true);
    missratAxis.setRange(0, maxMissrat * 1.1);

    // Add significance Threshold to subplot
    final Marker missingThresholdLine = new ValueMarker(missingThreshold);
    missingThresholdLine.setPaint(Color.blue);

    final Marker hetzyThresholdLine = new ValueMarker(hetzyThreshold);
    hetzyThresholdLine.setPaint(Color.blue);

    // Add legend to hetzyThreshold
    hetzyThresholdLine.setLabel("hetzyg. threshold = " + hetzyThreshold);
    missingThresholdLine.setLabel("missing. threshold = " + missingThreshold);
    hetzyThresholdLine.setLabelAnchor(RectangleAnchor.TOP_LEFT);
    hetzyThresholdLine.setLabelTextAnchor(TextAnchor.TOP_RIGHT);
    missingThresholdLine.setLabelAnchor(RectangleAnchor.BOTTOM_LEFT);
    missingThresholdLine.setLabelTextAnchor(TextAnchor.TOP_LEFT);
    plot.addRangeMarker(missingThresholdLine); // THIS FOR MISSING RATIO
    plot.addDomainMarker(hetzyThresholdLine); // THIS FOR HETZY RATIO

    // Marker label if below hetzyThreshold
    XYItemRenderer lblRenderer = plot.getRenderer();

    // THRESHOLD AND SELECTED LABEL GENERATOR
    MySeriesItemLabelGenerator lblGenerator = new MySeriesItemLabelGenerator(hetzyThreshold, missingThreshold);
    lblRenderer.setSeriesItemLabelGenerator(0, lblGenerator);
    lblRenderer.setSeriesItemLabelFont(0, new Font("SansSerif", Font.PLAIN, 10));
    lblRenderer.setSeriesPositiveItemLabelPosition(0, new ItemLabelPosition(ItemLabelAnchor.CENTER,
            TextAnchor.BOTTOM_LEFT, TextAnchor.BOTTOM_LEFT, 2 * Math.PI));

    // TOOLTIP GENERATOR
    MyXYToolTipGenerator tooltipGenerator = new MyXYToolTipGenerator();

    lblRenderer.setBaseToolTipGenerator(tooltipGenerator);

    lblRenderer.setSeriesItemLabelsVisible(0, true);

    return chart;
}

From source file:vis2006.VisGrafik.java

public JFreeChart createChart(Stand st, int speciesCode) {
    // create the dataset...
    int code = speciesCode;
    int merk = 0;
    for (int i = 0; i < st.nspecies; i++)
        if (st.sp[i].code == code)
            merk = i;/*from  w w w  .j ava  2 s.c  o m*/
    XYSeriesCollection dataset = new XYSeriesCollection();

    // Werte der Hhenkurve
    XYSeries series0 = new XYSeries("Hhenkurve: " + st.sp[merk].heightcurveUsed);
    for (int k = 0; k < st.ntrees; k++) {
        if ((st.tr[k].d > 0) && (st.tr[k].h > 0) && st.tr[k].code == code && st.tr[k].fac > 0.0)
            series0.add(st.tr[k].d, st.tr[k].h);
    }
    dataset.addSeries(series0);

    // Messwerte aus der Versuchsflche
    XYSeries series1 = new XYSeries("Messwerte");
    for (int k = 0; k < st.ntrees; k++) {
        if ((st.tr[k].d > 0) && (st.tr[k].hMeasuredValue > 0) && st.tr[k].code == code && st.tr[k].fac > 0.0)
            series1.add(st.tr[k].d, st.tr[k].hMeasuredValue);
    }
    dataset.addSeries(series1);

    // Andere Messwerte (HG, nurH) 
    XYSeries series2 = new XYSeries("Andere Hhen");
    for (int k = 0; k < st.ntrees; k++) {
        if ((st.tr[k].d > 0) && (st.tr[k].hMeasuredValue > 0) && st.tr[k].code == code
                && (st.tr[k].no.contains("nurH") || st.tr[k].no.contains("HG")))
            series2.add(st.tr[k].d, st.tr[k].hMeasuredValue);
    }
    dataset.addSeries(series2);

    /*   Wozu ist die gut?
         double dmin=9000;
         double dmax=-9000;
         for (int k=0;k<st.ntrees;k++){
             if (st.tr[k].code==st.sp[merk].code && st.tr[k].fac > 0.0){
    if (dmax <st.tr[k].d ) dmax=st.tr[k].d;
    if (dmin >st.tr[k].d ) dmin=st.tr[k].d;
     }
         }
            
         XYSeries series3 = new XYSeries("");
         int idmin = (int)(Math.round(dmin));
         int idmax = (int)(Math.round(dmax))+1;
         for (int k=idmin;k<=idmax;k++){
             double dwert=k*1.0;
             if (st.sp[merk].heightcurveUsed.indexOf("Einheits")>-1){
    UniformHeight uh = new UniformHeight();
    series3.add(dwert,uh.height(st.sp[merk],dwert,
                 st.sp[merk].dg,st.sp[merk].hg,st));        
             }
             else {
               HeightCurve hc =new HeightCurve(); 
               series3.add(dwert,hc.getHeight(st.sp[merk].spDef.heightCurve,dwert,st.sp[merk].heightcurveUsedP0,
                 st.sp[merk].heightcurveUsedP1,st.sp[merk].heightcurveUsedP2));
             }
           }
             dataset.addSeries(series3);
     */
    //     
    JFreeChart chart = ChartFactory.createScatterPlot("Hhenkurve  " + st.sp[merk].spDef.longName, "BHD [cm]",
            "Hhe [m]", dataset, org.jfree.chart.plot.PlotOrientation.VERTICAL, true, //legend
            false, // tooltips
            false); // urls
    XYPlot plot = chart.getXYPlot();
    plot.setDomainCrosshairVisible(true);
    plot.setRangeCrosshairVisible(true);
    plot.getDomainAxis().setAutoRangeMinimumSize(1.0);
    plot.getRangeAxis().setAutoRangeMinimumSize(5.0);

    //
    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();

    renderer.setSeriesLinesVisible(0, true); // Hhenkurve - rote Linie
    renderer.setSeriesStroke(0, new BasicStroke(2));
    renderer.setSeriesShapesVisible(0, false);
    renderer.setSeriesPaint(0, Color.RED);

    renderer.setSeriesLinesVisible(1, false); // Parzellenmesswerte - blaue Symbole
    renderer.setSeriesShapesVisible(1, true);
    renderer.setSeriesPaint(1, Color.BLUE);

    renderer.setSeriesLinesVisible(2, false); // Andere Messwerte - blaue leere Symbole
    renderer.setSeriesShapesVisible(2, true);
    renderer.setSeriesShapesFilled(2, false);
    renderer.setSeriesPaint(2, Color.BLUE);

    //     renderer.setSeriesLinesVisible(3, true);  
    //     renderer.setSeriesShapesVisible(3,false);
    //     renderer.setSeriesPaint(3, Color.BLUE);    
    //   renderer.setSeriesPaint(1, new Color(st.sp[merk].spDef.colorRed,st.sp[merk].spDef.colorGreen,st.sp[merk].spDef.colorBlue));

    plot.setRenderer(renderer);
    System.out.println("Plot done");

    return chart;
}

From source file:edu.ucla.stat.SOCR.applications.demo.PortfolioApplication.java

void updateGraph() {
    //System.out.println("UpdateGraph get called");
    setupStockOptions();//from   w w  w .j  av  a 2 s.com
    computeDataPoints();

    e_serie = new XYSeries("equal", false);
    b_serie = new XYSeries("bigger", false);
    s_serie = new XYSeries("smaller", false);
    m_serie = new XYSeries("mouse", false);

    StringBuffer text = new StringBuffer();
    text.append("mouse clicked at " + tooltip + "\n");
    text.append("The stock combinations are:");

    Iterator i = dataPoints.iterator();
    while (i.hasNext()) {
        DataPoint dp = (DataPoint) i.next();

        if (dp == minPoint) {
            e_serie.add(dp.std, dp.mean);
        } else if (dp.mean < minPoint.mean)
            s_serie.add(dp.std, dp.mean);
        else
            b_serie.add(dp.std, dp.mean);

        if (mouseClicked) {
            if (Double.parseDouble(tooltip_formatter.format(dp.std)) == Double
                    .parseDouble(tooltip_formatter.format(mouse_x))
                    && Double.parseDouble(tooltip_formatter.format(dp.mean)) == Double
                            .parseDouble(tooltip_formatter.format(mouse_y))) {

                for (int j = 0; j < numStocks; j++)
                    text.append("Stock " + (j + 1) + ": x[" + (j + 1) + "]=" + tooltip_formatter.format(dp.x[j])
                            + " ,");

                text.append("\n---\n");
            }
        }

    }
    if (!mouseClicked) {
        mouse_x = minPoint.std;
        mouse_y = minPoint.mean;
    }
    m_serie.add(mouse_x, mouse_y);

    XYSeriesCollection ds = new XYSeriesCollection();
    ds.addSeries(e_serie);
    ds.addSeries(m_serie);

    ds.addSeries(b_serie);
    ds.addSeries(s_serie);

    JFreeChart chart = ChartFactory.createXYLineChart("", // chart title
            "Risk (Standard Deviation)", // x axis label
            "Expected Return", // y axis label
            ds, // data
            PlotOrientation.VERTICAL, false, // include legend
            true, // tooltips
            false // urls
    );
    chart.setBackgroundPaint(Color.white);
    XYPlot subplot1 = (XYPlot) chart.getPlot();
    XYLineAndShapeRenderer renderer1 = (XYLineAndShapeRenderer) subplot1.getRenderer();

    renderer1.setSeriesPaint(1, Color.red);
    renderer1.setSeriesPaint(3, Color.blue);
    renderer1.setSeriesPaint(2, Color.blue); //grey
    renderer1.setSeriesPaint(0, Color.blue); //green
    Shape shape = renderer1.getBaseShape();
    renderer1.setSeriesShape(2, shape);
    renderer1.setSeriesShape(3, shape);
    renderer1.setBaseLinesVisible(false);
    renderer1.setBaseShapesVisible(true);
    renderer1.setBaseShapesFilled(true);

    chartPanel = new ChartPanel(chart, false);
    chartPanel.setPreferredSize(new Dimension(CHART_SIZE_X, CHART_SIZE_Y));
    chartPanel.addChartMouseListener(this);
    super.updateGraph(chartPanel);
    //

    if (mouseClicked) {

        getRecordTable().setText(text.toString());
    } else {
        text = new StringBuffer();
        text.append("(" + tooltip_formatter.format(minPoint.mean) + " , "
                + tooltip_formatter.format(minPoint.std) + ")\n");
        for (int j = 0; j < numStocks; j++)
            text.append("Stock " + (j + 1) + ": x[" + (j + 1) + "]=" + tooltip_formatter.format(minPoint.x[j])
                    + ",");
        text.append("\n---\n");
        getRecordTable().setText(text.toString());
        ;
    }

    mouseClicked = false;
}

From source file:no.ntnu.mmfplanner.ui.graph.NpvChart.java

/**
 * Helper method for updateModel(). Adds a rolling npv line with self
 * funding and break even, as well as adding legend elements
 *//*from   w  w w.  j av a  2  s.c om*/
private void addNpvLine(ProjectRoi projectRoi, String caption, Paint paint, XYSeriesCollection dataset,
        XYLineAndShapeRenderer renderer) {
    // adds the rolling npvseries and sets approperiate render properties
    XYSeries rollingNpv = new XYSeries(caption);
    rollingNpv.add(0.5, 0.0);
    for (int i = 0; i < projectRoi.rollingNpv.length; i++) {
        rollingNpv.add(i + 1.5, projectRoi.rollingNpv[i]);
    }

    int series = dataset.getSeriesCount();
    dataset.addSeries(rollingNpv);
    renderer.setSeriesShapesVisible(series, false);
    renderer.setSeriesStroke(series, STROKE_LINE);
    renderer.setSeriesPaint(series, paint);
    renderer.setSeriesVisibleInLegend(series, true);

    // break even
    if (projectRoi.breakevenPeriod > 0) {
        XYSeries breakEven = new XYSeries("Break Even");
        breakEven.add(projectRoi.breakevenRegression - 0.5, 0.0);

        series = dataset.getSeriesCount();
        dataset.addSeries(breakEven);
        renderer.setSeriesLinesVisible(series, false);
        renderer.setSeriesPaint(series, paint);
        renderer.setSeriesVisibleInLegend(series, false);
        renderer.setSeriesShape(series, ShapeUtilities.createDiamond(3.5f));
    }

    // selfFunding
    if (projectRoi.selfFundingPeriod > 1) {
        XYSeries selfFunding = new XYSeries("Self Funding");
        double x = projectRoi.selfFundingPeriod - 0.5;
        double y = projectRoi.rollingNpv[projectRoi.selfFundingPeriod - 2];
        selfFunding.add(x, y);

        series = dataset.getSeriesCount();
        dataset.addSeries(selfFunding);
        renderer.setSeriesLinesVisible(series, false);
        renderer.setSeriesPaint(series, paint);
        renderer.setSeriesVisibleInLegend(series, false);
        renderer.setSeriesShape(series, ShapeUtilities.createUpTriangle(3.5f));
    }

}