Example usage for org.jfree.data.xy XYSeriesCollection removeAllSeries

List of usage examples for org.jfree.data.xy XYSeriesCollection removeAllSeries

Introduction

In this page you can find the example usage for org.jfree.data.xy XYSeriesCollection removeAllSeries.

Prototype

public void removeAllSeries() 

Source Link

Document

Removes all the series from the collection and sends a DatasetChangeEvent to all registered listeners.

Usage

From source file:mzmatch.ipeak.align.CowCoda.java

@SuppressWarnings("unchecked")
public static void main(String args[]) {
    final String lbl_mcq = "mcq";

    try {// ww w .  j a  v  a  2  s. c  om
        Tool.init();

        // parse the commandline options
        final Options options = new Options();
        CmdLineParser cmdline = new CmdLineParser(options);

        // check whether we need to show the help
        cmdline.parse(args);
        if (options.help) {
            Tool.printHeader(System.out, application, version);
            cmdline.printUsage(System.out, "");
            return;
        }

        if (options.verbose) {
            Tool.printHeader(System.out, application, version);
            cmdline.printOptions();
        }

        // check the command-line parameters
        int filetype = JFreeChartTools.PDF;
        {
            if (options.ppm == -1) {
                System.err.println("[ERROR]: the ppm-value needs to be set.");
                System.exit(0);
            }
            if (options.order == -1) {
                System.err.println("[ERROR]: the order for the polynomial fit needs to be set.");
                System.exit(0);
            }
            if (options.maxrt == -1) {
                System.err.println("[ERROR]: the maximum retention time shift is not set.");
                System.exit(0);
            }

            if (options.image != null) {
                String extension = options.image.substring(options.image.lastIndexOf('.') + 1);
                if (extension.toLowerCase().equals("png"))
                    filetype = JFreeChartTools.PNG;
                else if (extension.toLowerCase().equals("pdf"))
                    filetype = JFreeChartTools.PDF;
                else {
                    System.err.println(
                            "[ERROR]: file extension of the image file needs to be either PDF or PNG.");
                    System.exit(0);
                }
            }

            // if the output directories do not exist, create them
            if (options.output != null)
                Tool.createFilePath(options.output, true);
            if (options.image != null)
                Tool.createFilePath(options.image, true);
            if (options.selection != null)
                Tool.createFilePath(options.selection, true);
        }

        // load the data
        if (options.verbose)
            System.out.println("Loading the data");
        double maxrt = 0;
        Vector<ParseResult> data = new Vector<ParseResult>();
        Vector<IPeakSet<IPeak>> matchdata = new Vector<IPeakSet<IPeak>>();
        for (String file : options.input) {
            System.out.println("- " + new File(file).getName());

            // load the mass chromatogram data
            ParseResult result = PeakMLParser.parse(new FileInputStream(file), true);
            data.add(result);

            // select the best mass chromatograms
            Vector<IPeak> selection = new Vector<IPeak>();
            for (IPeak peak : (IPeakSet<IPeak>) result.measurement) {
                maxrt = Math.max(maxrt, maxRT(peak));

                double mcq = codaDW(peak);
                peak.addAnnotation(lbl_mcq, Double.toString(mcq), Annotation.ValueType.DOUBLE);
                if (mcq >= options.codadw)
                    selection.add(peak);
            }

            // keep track of the selected mass chromatograms
            int id = options.input.indexOf(file);
            IPeakSet<IPeak> peakset = new IPeakSet<IPeak>(selection);
            peakset.setMeasurementID(id);
            for (IPeak mc : peakset)
                mc.setMeasurementID(id);
            matchdata.add(peakset);
        }

        // match the selection together
        if (options.verbose)
            System.out.println("Matching the data");
        Vector<IPeakSet<IPeak>> matches = IPeak.match((Vector) matchdata, options.ppm,
                new IPeak.MatchCompare<IPeak>() {
                    public double distance(IPeak peak1, IPeak peak2) {
                        double diff = Math.abs(peak1.getRetentionTime() - peak2.getRetentionTime());
                        if (diff > options.maxrt)
                            return -1;

                        Signal signal1 = new Signal(peak1.getSignal());
                        signal1.normalize();
                        Signal signal2 = new Signal(peak2.getSignal());
                        signal2.normalize();

                        double offset = bestOffSet(peak1, peak2, options.maxrt);
                        for (int i = 0; i < signal2.getSize(); ++i)
                            signal2.getX()[i] += offset;

                        double correlation = signal2
                                .pearsonsCorrelation(signal1)[Statistical.PEARSON_CORRELATION];
                        if (correlation < 0.5)
                            return -1;

                        // the match-function optimizes toward 0 (it's a distance)
                        return 1 - correlation;
                    }
                });

        // filter out all incomplete sets
        Vector<IPeakSet<IPeak>> valids = new Vector<IPeakSet<IPeak>>();
        for (IPeakSet<IPeak> set : matches) {
            if (set.size() < options.input.size())
                continue;
            valids.add((IPeakSet) set);
        }

        // calculate the alignment factors
        if (options.verbose)
            System.out.println("Calculating the alignment factors");
        double medians[] = new double[valids.size() + 2];
        DataFrame.Double dataframe = new DataFrame.Double(valids.size() + 2, options.input.size());

        medians[0] = 0;
        medians[medians.length - 1] = maxrt;
        for (int i = 0; i < options.input.size(); ++i) {
            dataframe.set(0, i, 0.1);
            dataframe.set(dataframe.getNrRows() - 1, i, 0);
        }

        for (int matchid = 0; matchid < valids.size(); ++matchid) {
            IPeakSet<IPeak> match = valids.get(matchid);

            // find the most central
            double offsets[][] = new double[match.size()][match.size()];
            for (int i = 0; i < match.size(); ++i)
                for (int j = i + 1; j < match.size(); ++j) {
                    offsets[i][j] = bestOffSet(match.get(i), match.get(j), options.maxrt);
                    offsets[j][i] = -offsets[i][j];
                }

            int besti = 0;
            double bestabssum = Double.MAX_VALUE;
            for (int i = 0; i < match.size(); ++i) {
                double abssum = 0;
                for (int j = 0; j < match.size(); ++j)
                    abssum += Math.abs(offsets[i][j]);
                if (abssum < bestabssum) {
                    besti = i;
                    bestabssum = abssum;
                }
            }

            for (int i = 0; i < match.size(); ++i)
                dataframe.set(matchid + 1, match.get(i).getMeasurementID(),
                        (i == besti ? 0 : offsets[i][besti]));

            medians[matchid + 1] = match.get(besti).getRetentionTime();
            dataframe.setRowName(matchid, Double.toString(match.get(besti).getRetentionTime()));
        }
        double minmedian = Statistical.min(medians);
        double maxmedian = Statistical.max(medians);

        // calculate for each profile the correction function
        PolynomialFunction functions[] = new PolynomialFunction[valids.size()];
        for (int i = 0; i < options.input.size(); ++i)
            functions[i] = PolynomialFunction.fit(options.order, medians, dataframe.getCol(i));

        // make a nice plot out of the whole thing
        if (options.verbose)
            System.out.println("Writing results");
        if (options.image != null) {
            org.jfree.data.xy.XYSeriesCollection dataset = new org.jfree.data.xy.XYSeriesCollection();
            JFreeChart linechart = ChartFactory.createXYLineChart(null, "Retention Time (seconds)", "offset",
                    dataset, PlotOrientation.VERTICAL, true, // legend
                    false, // tooltips
                    false // urls
            );

            // setup the colorkey
            Colormap colormap = new Colormap(Colormap.EXCEL);

            // get the structure behind the graph
            XYPlot plot = (XYPlot) linechart.getPlot();
            XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) plot.getRenderer();

            // setup the plot area
            linechart.setBackgroundPaint(java.awt.Color.WHITE);
            linechart.setBorderVisible(false);
            linechart.setAntiAlias(true);

            plot.setBackgroundPaint(java.awt.Color.WHITE);
            plot.setDomainGridlinesVisible(true);
            plot.setRangeGridlinesVisible(true);

            // create the datasets
            for (int i = 0; i < options.input.size(); ++i) {
                org.jfree.data.xy.XYSeries series = new org.jfree.data.xy.XYSeries(dataframe.getColName(i));
                org.jfree.data.xy.XYSeries function = new org.jfree.data.xy.XYSeries(
                        dataframe.getColName(i) + "-function");
                dataset.addSeries(series);
                dataset.addSeries(function);

                renderer.setSeriesPaint(dataset.getSeriesCount() - 1, new java.awt.Color(colormap.getColor(i)));
                renderer.setSeriesPaint(dataset.getSeriesCount() - 2, new java.awt.Color(colormap.getColor(i)));

                renderer.setSeriesLinesVisible(dataset.getSeriesCount() - 2, false);
                renderer.setSeriesShapesVisible(dataset.getSeriesCount() - 2, true);

                // add the data-points
                for (int j = 0; j < valids.size(); ++j)
                    series.add(medians[j], dataframe.get(j, i));
                for (double x = minmedian; x < maxmedian; ++x)
                    function.add(x, functions[i].getY(x));
            }

            dataset.removeAllSeries();
            for (int i = 0; i < options.input.size(); ++i) {
                Function function = functions[i];

                org.jfree.data.xy.XYSeries series = new org.jfree.data.xy.XYSeries(dataframe.getColName(i));
                dataset.addSeries(series);

                renderer.setSeriesPaint(i, new java.awt.Color(colormap.getColor(i)));
                renderer.setSeriesLinesVisible(i, false);
                renderer.setSeriesShapesVisible(i, true);

                // add the data-points
                for (int j = 0; j < valids.size(); ++j)
                    series.add(medians[j], dataframe.get(j, i) - function.getY(medians[j]));
            }

            JFreeChartTools.writeAs(filetype, new FileOutputStream(options.image), linechart, 800, 500);
        }

        // save the selected
        if (options.selection != null) {
            Header header = new Header();

            // set the number of peaks to be stored
            header.setNrPeaks(valids.size());

            // create a set for the measurements
            SetInfo set = new SetInfo("", SetInfo.SET);
            header.addSetInfo(set);

            // create the measurement infos
            for (int i = 0; i < options.input.size(); ++i) {
                String file = options.input.get(i);

                // create the measurement info
                MeasurementInfo measurement = new MeasurementInfo(i, data.get(i).header.getMeasurementInfo(0));
                measurement.addFileInfo(new FileInfo(file, file));

                header.addMeasurementInfo(measurement);

                // add the file to the set
                set.addChild(new SetInfo(file, SetInfo.SET, i));
            }

            // write the data
            PeakMLWriter.write(header, (Vector) valids, null,
                    new GZIPOutputStream(new FileOutputStream(options.selection)), null);
        }

        // correct the values with the found function and save them
        for (int i = 0; i < options.input.size(); ++i) {
            Function function = functions[i];
            ParseResult result = data.get(i);

            IPeakSet<MassChromatogram<Peak>> peakset = (IPeakSet<MassChromatogram<Peak>>) result.measurement;
            for (IPeak peak : peakset)
                align(peak, function);

            File filename = new File(options.input.get(i));
            String name = filename.getName();

            PeakMLWriter.write(result.header, (Vector) peakset.getPeaks(), null,
                    new GZIPOutputStream(new FileOutputStream(options.output + "/" + name)), null);
        }
    } catch (Exception e) {
        Tool.unexpectedError(e, application);
    }
}

From source file:lu.lippmann.cdb.lab.mds.MDSViewBuilder.java

/**
 * //from w  w w  .  j a  v a 2  s . c om
 */
private static void buildFilteredSeries(final MDSResult mdsResult, final XYPlot xyPlot,
        final String... attrNameToUseAsPointTitle) throws Exception {

    final CollapsedInstances distMdsRes = mdsResult.getCInstances();
    final Instances instances = distMdsRes.getInstances();

    final SimpleMatrix coordinates = mdsResult.getCoordinates();

    final Instances collapsedInstances = mdsResult.getCollapsedInstances();
    int maxSize = 0;
    if (distMdsRes.isCollapsed()) {
        final List<Instances> clusters = distMdsRes.getCentroidMap().getClusters();
        final int nbCentroids = clusters.size();
        maxSize = clusters.get(0).size();
        for (int i = 1; i < nbCentroids; i++) {
            final int currentSize = clusters.get(i).size();
            if (currentSize > maxSize) {
                maxSize = currentSize;
            }
        }
    }

    Attribute clsAttribute = null;
    int nbClass = 1;
    if (instances.classIndex() != -1) {
        clsAttribute = instances.classAttribute();
        nbClass = clsAttribute.numValues();
    }
    final XYSeriesCollection dataset = (XYSeriesCollection) xyPlot.getDataset();
    final int fMaxSize = maxSize;

    final List<XYSeries> lseries = new ArrayList<XYSeries>();

    //No class : add one dummy serie
    if (nbClass <= 1) {
        lseries.add(new XYSeries("Serie #1", false));
    } else {
        //Some class : add one serie per class
        for (int i = 0; i < nbClass; i++) {
            lseries.add(new XYSeries(clsAttribute.value(i), false));
        }
    }
    dataset.removeAllSeries();

    /**
     * Initialize filtered series
     */
    final List<Instances> filteredInstances = new ArrayList<Instances>();
    for (int i = 0; i < lseries.size(); i++) {
        filteredInstances.add(new Instances(collapsedInstances, 0));
    }

    final Map<Tuple<Integer, Integer>, Integer> correspondanceMap = new HashMap<Tuple<Integer, Integer>, Integer>();
    for (int i = 0; i < collapsedInstances.numInstances(); i++) {
        final Instance oInst = collapsedInstances.instance(i);
        int indexOfSerie = 0;
        if (oInst.classIndex() != -1) {
            if (distMdsRes.isCollapsed()) {
                indexOfSerie = getStrongestClass(i, distMdsRes);
            } else {
                indexOfSerie = (int) oInst.value(oInst.classAttribute());
            }
        }
        lseries.get(indexOfSerie).add(coordinates.get(i, 0), coordinates.get(i, 1));

        filteredInstances.get(indexOfSerie).add(oInst);
        if (distMdsRes.isCollapsed()) {
            correspondanceMap.put(new Tuple<Integer, Integer>(indexOfSerie,
                    filteredInstances.get(indexOfSerie).numInstances() - 1), i);
        }
    }

    final List<Paint> colors = new ArrayList<Paint>();

    for (final XYSeries series : lseries) {
        dataset.addSeries(series);
    }

    if (distMdsRes.isCollapsed()) {
        final XYLineAndShapeRenderer xyRenderer = new XYLineAndShapeRenderer(false, true) {
            private static final long serialVersionUID = -6019883886470934528L;

            @Override
            public void drawItem(Graphics2D g2, XYItemRendererState state, java.awt.geom.Rectangle2D dataArea,
                    PlotRenderingInfo info, XYPlot plot, ValueAxis domainAxis, ValueAxis rangeAxis,
                    XYDataset dataset, int series, int item, CrosshairState crosshairState, int pass) {

                if (distMdsRes.isCollapsed()) {

                    final Integer centroidIndex = correspondanceMap
                            .get(new Tuple<Integer, Integer>(series, item));
                    final Instances cluster = distMdsRes.getCentroidMap().getClusters().get(centroidIndex);
                    int size = cluster.size();

                    final int shapeSize = (int) (MAX_POINT_SIZE * size / fMaxSize + 1);

                    final double x1 = plot.getDataset().getX(series, item).doubleValue();
                    final double y1 = plot.getDataset().getY(series, item).doubleValue();

                    Map<Object, Integer> mapRepartition = new HashMap<Object, Integer>();
                    mapRepartition.put("No class", size);
                    if (cluster.classIndex() != -1) {
                        mapRepartition = WekaDataStatsUtil.getClassRepartition(cluster);
                    }

                    final RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
                    final RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
                    final double fx = domainAxis.valueToJava2D(x1, dataArea, xAxisLocation);
                    final double fy = rangeAxis.valueToJava2D(y1, dataArea, yAxisLocation);

                    setSeriesShape(series,
                            new Ellipse2D.Double(-shapeSize / 2, -shapeSize / 2, shapeSize, shapeSize));

                    super.drawItem(g2, state, dataArea, info, plot, domainAxis, rangeAxis, dataset, series,
                            item, crosshairState, pass);

                    //Draw pie
                    if (ENABLE_PIE_SHART) {
                        createPieChart(g2, (int) (fx - shapeSize / 2), (int) (fy - shapeSize / 2), shapeSize,
                                mapRepartition, size, colors);
                    }

                } else {

                    super.drawItem(g2, state, dataArea, info, plot, domainAxis, rangeAxis, dataset, series,
                            item, crosshairState, pass);

                }

            }

        };

        xyPlot.setRenderer(xyRenderer);
    }

    final XYToolTipGenerator gen = new XYToolTipGenerator() {
        @Override
        public String generateToolTip(XYDataset dataset, int series, int item) {
            if (distMdsRes.isCollapsed()) {
                final StringBuilder res = new StringBuilder("<html>");
                final Integer centroidIndex = correspondanceMap.get(new Tuple<Integer, Integer>(series, item));
                final Instance centroid = distMdsRes.getCentroidMap().getCentroids().get(centroidIndex);
                final Instances cluster = distMdsRes.getCentroidMap().getClusters().get(centroidIndex);

                //Set same class index for cluster than for original instances
                //System.out.println("Cluster index = "  + cluster.classIndex() + "/" + instances.classIndex());
                cluster.setClassIndex(instances.classIndex());

                Map<Object, Integer> mapRepartition = new HashMap<Object, Integer>();
                mapRepartition.put("No class", cluster.size());
                if (cluster.classIndex() != -1) {
                    mapRepartition = WekaDataStatsUtil.getClassRepartition(cluster);
                }
                res.append(InstanceFormatter.htmlFormat(centroid, false)).append("<br/>");
                for (final Map.Entry<Object, Integer> entry : mapRepartition.entrySet()) {
                    if (entry.getValue() != 0) {
                        res.append("Class :<b>'" + StringEscapeUtils.escapeHtml(entry.getKey().toString())
                                + "</b>' -> " + entry.getValue()).append("<br/>");
                    }
                }
                res.append("</html>");
                return res.toString();
            } else {
                //return InstanceFormatter.htmlFormat(filteredInstances.get(series).instance(item),true);
                return InstanceFormatter.shortHtmlFormat(filteredInstances.get(series).instance(item));
            }
        }
    };

    final Shape shape = new Ellipse2D.Float(0f, 0f, MAX_POINT_SIZE, MAX_POINT_SIZE);

    ((XYLineAndShapeRenderer) xyPlot.getRenderer()).setUseOutlinePaint(true);

    for (int p = 0; p < nbClass; p++) {
        xyPlot.getRenderer().setSeriesToolTipGenerator(p, gen);
        ((XYLineAndShapeRenderer) xyPlot.getRenderer()).setLegendShape(p, shape);
        xyPlot.getRenderer().setSeriesOutlinePaint(p, Color.BLACK);
    }

    for (int ii = 0; ii < nbClass; ii++) {
        colors.add(xyPlot.getRenderer().getItemPaint(ii, 0));
    }

    if (attrNameToUseAsPointTitle.length > 0) {
        final Attribute attrToUseAsPointTitle = instances.attribute(attrNameToUseAsPointTitle[0]);
        if (attrToUseAsPointTitle != null) {
            final XYItemLabelGenerator lg = new XYItemLabelGenerator() {
                @Override
                public String generateLabel(final XYDataset dataset, final int series, final int item) {
                    return filteredInstances.get(series).instance(item).stringValue(attrToUseAsPointTitle);
                }
            };
            xyPlot.getRenderer().setBaseItemLabelGenerator(lg);
            xyPlot.getRenderer().setBaseItemLabelsVisible(true);
        }
    }
}

From source file:sim.util.media.chart.TimeSeriesChartGenerator.java

public void moveSeries(int index, boolean up) {
    super.moveSeries(index, up);

    if ((index > 0 && up) || (index < getSeriesCount() - 1 && !up)) // it's not the first or the last given the move
    {//from  w  w  w.  j a va2  s  . c om
        XYSeriesCollection xysc = (XYSeriesCollection) getSeriesDataset();
        // this requires removing everything from the dataset and resinserting, duh
        ArrayList items = new ArrayList(xysc.getSeries());
        xysc.removeAllSeries();

        int delta = up ? -1 : 1;
        // now rearrange
        items.add(index + delta, items.remove(index));

        // rebuild the dataset
        for (int i = 0; i < items.size(); i++)
            xysc.addSeries(((XYSeries) (items.get(i))));
    }
}

From source file:edu.gmu.cs.sim.util.media.chart.TimeSeriesChartGenerator.java

public void moveSeries(int index, boolean up) {
    super.moveSeries(index, up);

    if ((index > 0 && up) || (index < getSeriesCount() - 1 && !up)) // it's not the first or the last given the move
    {//from   w w  w  .j a  v  a 2 s  .com
        XYSeriesCollection xysc = (XYSeriesCollection) getSeriesDataset();
        // this requires removing everything from the dataset and resinserting, duh
        ArrayList items = new ArrayList(xysc.getSeries());
        xysc.removeAllSeries();

        int delta = up ? -1 : 1;
        // now rearrange
        items.add(index + delta, items.remove(index));

        // rebuild the dataset
        for (int i = 0; i < items.size(); i++) {
            xysc.addSeries(((XYSeries) (items.get(i))));
        }
    }
}

From source file:edu.fullerton.viewerplugin.PluginSupport.java

public static int scaleRange(XYSeriesCollection mtds, Double miny, Double maxy) {
    int exp = PluginSupport.getExp(miny, maxy);
    if (exp > 0 && exp < 100) {
        int nseries = mtds.getSeriesCount();
        XYSeries[] newSeries = new XYSeries[nseries];

        double scale = Math.pow(10, exp);
        for (int s = 0; s < nseries; s++) {
            XYSeries ds = (XYSeries) mtds.getSeries(s);
            Comparable skey = mtds.getSeriesKey(s);
            XYSeries nds = new XYSeries(skey, true);
            for (int item = 0; item < ds.getItemCount(); item++) {
                double x = ds.getX(item).doubleValue();
                double y = ds.getY(item).doubleValue();

                y *= scale;/*  w  w  w . j av a2s. co  m*/
                nds.add(x, y);
            }
            newSeries[s] = nds;
        }
        mtds.removeAllSeries();
        for (int s = 0; s < nseries; s++) {
            mtds.addSeries(newSeries[s]);
        }
    } else {
        exp = 0;
    }
    return exp;
}

From source file:com.anrisoftware.prefdialog.miscswing.multichart.freechart.FreechartXYChart.java

private void setupData(int row0, int row1) {
    ChartModel model = this.model;
    int cols = model.getColumnCount();
    XYSeriesCollection dataset = getCategory();
    dataset.removeAllSeries();
    for (int i = 0; i < cols; i++) {
        XYSeries series = new XYSeries(model.getColumnName(i), false, false);
        dataset.addSeries(series);/*www .  j  av  a  2s  .c o m*/
    }
}

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);
        }// w  w w.jav  a2s  .c  om

        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:tw.edu.sju.ee.eea.module.iepe.file.IepeVoltageElement.java

private void repaintChart() {
    //        JFreeChart chart = ((ChartPanel) chartPanel).getChart();
    //        chart = null;
    //        ((ChartPanel) chartPanel).setChart(createChart());
    XYSeriesCollection sc = ((XYSeriesCollection) ((ChartPanel) chartPanel).getChart().getXYPlot()
            .getDataset());// www.  j ava 2 s.  c  om
    //        XYSeries series = sc.getSeries(0);
    //        series.clear();
    //        SampledStream ss = new
    sc.removeAllSeries();
    sc.addSeries(SampledChart.series("Ch_0", info.getInputStream(), index, info.getSamplerate(), length));
    chartScroll = true;
}

From source file:lu.lippmann.cdb.lab.mds.UniversalMDS.java

public JXPanel buildMDSViewFromDataSet(Instances ds, MDSTypeEnum type) throws Exception {

    final XYSeriesCollection dataset = new XYSeriesCollection();

    final JFreeChart chart = ChartFactory.createScatterPlot("", // title 
            "X", "Y", // axis labels 
            dataset, // dataset 
            PlotOrientation.VERTICAL, true, // legend? yes 
            true, // tooltips? yes 
            false // URLs? no 
    );//  w w  w  .  j a  va 2s.c o m

    final XYPlot xyPlot = (XYPlot) chart.getPlot();

    chart.setTitle(type.name() + " MDS");

    Attribute clsAttribute = null;
    int nbClass = 1;
    if (ds.classIndex() != -1) {
        clsAttribute = ds.classAttribute();
        nbClass = clsAttribute.numValues();
    }

    final List<XYSeries> lseries = new ArrayList<XYSeries>();
    if (nbClass <= 1) {
        lseries.add(new XYSeries("Serie #1", false));
    } else {
        for (int i = 0; i < nbClass; i++) {
            lseries.add(new XYSeries(clsAttribute.value(i), false));
        }
    }
    dataset.removeAllSeries();

    /**
     * Initialize filtered series
     */
    final List<Instances> filteredInstances = new ArrayList<Instances>();
    for (int i = 0; i < lseries.size(); i++) {
        filteredInstances.add(new Instances(ds, 0));
    }

    for (int i = 0; i < ds.numInstances(); i++) {
        final Instance oInst = ds.instance(i);
        int indexOfSerie = 0;
        if (oInst.classIndex() != -1) {
            indexOfSerie = (int) oInst.value(oInst.classAttribute());
        }
        lseries.get(indexOfSerie).add(coordinates[i][0], coordinates[i][1]);
        filteredInstances.get(indexOfSerie).add(oInst);
    }

    final List<Paint> colors = new ArrayList<Paint>();

    for (final XYSeries series : lseries) {
        dataset.addSeries(series);
    }

    final XYToolTipGenerator gen = new XYToolTipGenerator() {
        @Override
        public String generateToolTip(XYDataset dataset, int series, int item) {
            return InstanceFormatter.htmlFormat(filteredInstances.get(series).instance(item), true);
        }
    };

    final Shape shape = new Ellipse2D.Float(0f, 0f, 5f, 5f);

    ((XYLineAndShapeRenderer) xyPlot.getRenderer()).setUseOutlinePaint(true);

    for (int p = 0; p < nbClass; p++) {
        xyPlot.getRenderer().setSeriesToolTipGenerator(p, gen);
        ((XYLineAndShapeRenderer) xyPlot.getRenderer()).setLegendShape(p, shape);
        xyPlot.getRenderer().setSeriesOutlinePaint(p, Color.BLACK);
    }

    for (int ii = 0; ii < nbClass; ii++) {
        colors.add(xyPlot.getRenderer().getItemPaint(ii, 0));
    }

    final ChartPanel chartPanel = new ChartPanel(chart);
    chartPanel.setMouseWheelEnabled(true);
    chartPanel.setPreferredSize(new Dimension(1200, 900));
    chartPanel.setBorder(new TitledBorder("MDS Projection"));
    chartPanel.setBackground(Color.WHITE);

    final JXPanel allPanel = new JXPanel();
    allPanel.setLayout(new BorderLayout());
    allPanel.add(chartPanel, BorderLayout.CENTER);

    return allPanel;
}

From source file:org.fhcrc.cpl.viewer.gui.SpectrumComponent.java

/**
 * update the chart with new data//from ww w .ja  va 2  s  .c om
 */
public void updateChart(boolean preserveDomain) {
    _log.debug("updateChart: start");
    float[][] spectrumIN = null;
    MSRun run = (MSRun) ApplicationContext.getProperty(SharedProperties.MS_RUN);
    MSRun.MSScan selectedScan = getSelectedScan();

    FloatRange rangeSpectrum = null; // restricted range of displayed data (for autoZoom)
    Pair<Spectrum.Peak, Spectrum.Peak> chartRange = null; // tell other components what we are displaying

    Range domainRange = null;
    if (preserveDomain && _chart != null)
        domainRange = _chart.getXYPlot().getDomainAxis().getRange();

    if (null == run || null == selectedScan) {
        clearChart();
        //if no chart to display, show white background
        chartArea.setBackground(java.awt.Color.WHITE);
        return;
    }

    chartArea.setBackground(_backgroundColor);

    if ("scan".equals(_type)) {
        scanSpinner.setValue(new Integer(selectedScan.getNum()));
        double t = selectedScan.getDoubleRetentionTime();
        timeTextField.setText("" + Math.round(t * 10) / 10.0);
        scanSpinner.setEnabled(true);
        //mzTextField.setText("");
        //mzTextField.setEnabled(false);
        mzSpinner.setValue(new Double(_selectedMZ));
        mzSpinner.setEnabled(false);

        /*         ArrayList l = new ArrayList();
                 l.add(selectedScan.getSpectrum());
                    spectrumIN = Spectrum.CombineRawSpectra(
            run.getTemplateSpectrum(),
            l,
            new FloatRange(selectedScan.getLowMz(),selectedScan.getHighMz())
            ); */

        spectrumIN = selectedScan.getSpectrum();

        if (autoZoom()) {
            // we don't want to filter the analyzed data, in case
            // that affects any of the algorithms
            // we only filter the result Datasets
            // UNDONE: choose range based on size of MSDetailPanel

            // range of 27+ is enough to see 4 ICAT labelled features (9*(4-1))
            rangeSpectrum = new FloatRange((float) _selectedMZ - 10F, (float) _selectedMZ + 30F);
        }

        if (null == rangeSpectrum) {
            chartRange = new Pair<Spectrum.Peak, Spectrum.Peak>(
                    new Spectrum.Peak(_selectedScanNum, spectrumIN[0][0], 0.0F),
                    new Spectrum.Peak(_selectedScanNum, spectrumIN[0][spectrumIN[0].length - 1]));
        } else {
            chartRange = new Pair<Spectrum.Peak, Spectrum.Peak>(
                    new Spectrum.Peak(_selectedScanNum, rangeSpectrum.min, 0.0F),
                    new Spectrum.Peak(_selectedScanNum, rangeSpectrum.max, 0.0F));
        }
    } else // elution
    {
        if (_selectedMZ == -1) {
            clearChart();
            return;
        }

        int RESAMPLE = 36;
        float mz = (float) Math.round(_selectedMZ * RESAMPLE) / RESAMPLE;
        _log.debug("updateChart mz=" + mz);

        scanSpinner.setValue(new Integer(selectedScan.getNum()));
        scanSpinner.setEnabled(false);
        double t = selectedScan.getDoubleRetentionTime();
        timeTextField.setText("" + Math.round(t * 10) / 10.0);
        //mzTextField.setText("" + mz);
        //mzTextField.setEnabled(true);
        mzSpinner.setValue(new Double(_selectedMZ));
        mzSpinner.setEnabled(true);

        FloatArray arrayIntensity = new FloatArray();
        FloatArray arrayScan = new FloatArray();
        int scanIndex = run.getIndexForScanNum(selectedScan.getNum());
        int scanStart = Math.max(0, scanIndex - 64);
        int scanEnd = Math.min(run.getScanCount() - 1, scanStart + 128);
        FloatRange r = new FloatRange(mz, mz);
        for (int s = scanStart; s < scanEnd; s++) {
            MSRun.MSScan scan = run.getScan(s);
            float[][] spectrumRaw = scan.getSpectrum();
            float[] resample = Spectrum.Resample(spectrumRaw, r, RESAMPLE);
            float f = resample[0];
            arrayIntensity.add(f);
            //arrayScan.add((float)scan.getDoubleRetentionTime());
            //            arrayScan.add((float)s);
            arrayScan.add((float) scan.getNum());
        }
        spectrumIN = new float[][] { arrayScan.toArray(null), arrayIntensity.toArray(null) };

        chartRange = new Pair<Spectrum.Peak, Spectrum.Peak>(
                new Spectrum.Peak(run.getScan(scanStart).getNum(), mz, 0.0F),
                new Spectrum.Peak(run.getScan(scanEnd).getNum(), mz, 0.0F));
    }

    String mode = (String) displayMode.getSelectedItem();

    java.util.List<XYSeriesCollection> listMultipleCharts = null;
    XYSeriesCollection series = new XYSeriesCollection();
    series.setIntervalWidth(0.0);

    //
    // Process source spectrum
    //

    float[][] spectrum = new float[][] { (float[]) spectrumIN[0].clone(), (float[]) spectrumIN[1].clone() };
    ProcessSpectrum: {
        if ("raw".equals(mode)) {
            break ProcessSpectrum;
        }

        if ("background centroided".equals(mode)) {
            if (run.getHeaderInfo().getDataProcessing().getCentroided() == 1)
                spectrum = FeatureStrategyCentroided.backgroundSpectrum(spectrum);
            break ProcessSpectrum;
        }

        if ("clean centroided".equals(mode)) {
            if (run.getHeaderInfo().getDataProcessing().getCentroided() == 1)
                spectrum = FeatureStrategyCentroided.cleanSpectrum(spectrum);
            break ProcessSpectrum;
        }

        // all subsequent processing expects resampling
        // don't resample elution profile
        if ("scan".equals(_type)) {
            int len = spectrum[0].length;
            spectrum = Spectrum.ResampleSpectrum(spectrumIN,
                    new FloatRange((float) Math.floor(spectrum[0][0]), (float) Math.ceil(spectrum[0][len - 1])),
                    36, false);
        } else {
            spectrum[1] = Spectrum.MedianSmooth(spectrum[1]);
            Spectrum.SmoothALittle(spectrum[1]);
        }

        if ("resampled".equals(mode))
            break ProcessSpectrum;

        /*         if ("compressed".equals(mode)) (data encoding test)
                    {
                    float[] s = spectrum[1];
                    short c[] = new short[s.length];
                    double m = 1.0;
                    for (int i = 0 ; i<c.length ; i++)
                       m = Math.max(m, s[i]);
                    double sqrt = Math.sqrt(m+1);
                    m = Math.round(Math.log(sqrt))+1;
                    double f = Math.floor(0x7fff / Math.log(sqrt));
                    m = 0;
                    for (int i = 0 ; i<c.length ; i++)
                       {
                       c[i] = (short)(Math.round(Math.log((s[i]+1)/sqrt) * f));
                       m = Math.max(m, Math.abs(c[i]));
                       }
                    System.err.println("MAX " + m);
                    for (int i = 0 ; i<c.length ; i++)
                       s[i] = (float)((Math.exp((double)c[i]/f) * sqrt) - 1);
                    break ProcessSpectrum;
                    } */

        // remove background for further processing
        if (run.getHeaderInfo().getDataProcessing().getCentroided() != 1) {
            int window = "scan".equals(_type) ? 72 : 15;
            float x[] = spectrum[1];
            float bg[] = Spectrum.MinimaWindow(x, spectrum[0].length, window, null);
            for (int i = 0; i < bg.length; i++)
                bg[i] = Math.max(0, x[i] - bg[i]);
            spectrum = new float[][] { spectrum[0], bg };
        }

        if ("subtract background".equals(mode))
            break ProcessSpectrum;

        if (mode.startsWith("threshold")) {
            spectrum[1] = Spectrum.WaveletD3(spectrum[1], null);
            break ProcessSpectrum;
        }

        if ("peaks".equals(mode) || "smoothed".equals(mode)) {
            if ("scan".equals(_type)) {
                double s = Smooth2D.smoothYfactor;
                spectrum[1] = Spectrum.FFTsmooth(spectrum[1], s, false);
            } else {
                //FeatureStrategyPeakClusters.smoothTHRESHOLD sm = new FeatureStrategyPeakClusters.smoothTHRESHOLD();
                spectrum[1] = SmootherCreator._thresholdElution(spectrum[1]);
            }
            break ProcessSpectrum;
        }
    } // ProcessSpectrum:

    //
    // This is the source spectrum
    //

    String name = mode.indexOf("peaks") != -1 ? "-spectrum" : "|spectrum";
    series.addSeries(new SpectrumXYSeries(name, spectrum, rangeSpectrum));
    _spectrum = spectrum;

    //
    // add additional series/charts
    //

    // show min/med for reference
    if (mode.equals("resampled") || mode.equals("subtract background")) {
        float[] T;
        if (mode.equals("resampled")) {
            T = Spectrum.MinimaWindow(spectrum[1], spectrum[0].length, 72, null);
            series.addSeries(new SpectrumXYSeries("-min", new float[][] { spectrum[0], T }, rangeSpectrum));
        }
        T = Spectrum.MedianWindow(spectrum[1], spectrum[0].length, 72, false);
        series.addSeries(new SpectrumXYSeries("-med", new float[][] { spectrum[0], T }, rangeSpectrum));
    }

    if (mode.startsWith("wavelet decomposition") || mode.startsWith("wavelet multiresolution")) {
        Filter f = new Filter("haar");
        float[] signal = spectrum[1]; // Spectrum.PadToDouble(spectrum[1], 32);
        int N = spectrum[0].length; // signal.length;
        int levels = 5;

        //if ("wavelet decomposition 2".equals(mode)) Spectrum.SmoothALittle(signal);

        float[][] modwt1 = Transform.decompose(signal, N, levels, f, "modwt", "periodic", null);
        float[][] t = modwt1;

        if ("wavelet multiresolution".equals(mode)) {
            t = Transform.multiresolution(t, N, levels, f, "modwt", "periodic", null);
        } else if ("wavelet decomposition 2".equals(mode)) {
            float[][] mra = Transform.multiresolution(t, N, levels, f, "modwt", "periodic", null);
            float[][] modwt2 = Transform.decompose(t[2], N, levels, f, "modwt", "periodic", null);
            // show original, d1, and d2
            float[] a = modwt1[2];
            float[] b = modwt2[2];
            float[] m = mra[2];
            Spectrum.Rotate(a, -3);
            Spectrum.Rotate(b, -7);
            t = new float[][] { a, /*b,*/ m }; // b is a mirror image of m
        }

        // copy array into data series
        listMultipleCharts = new java.util.LinkedList<XYSeriesCollection>();
        XYSeriesCollection ds = new XYSeriesCollection(
                new SpectrumXYSeries("spectrum", spectrum, rangeSpectrum));
        ds.setIntervalWidth(0.0);
        listMultipleCharts.add(ds);
        for (int i = 0; i < t.length; i++) {
            //float[] s = Spectrum.UnpadToFloat(t[i], 32, null);
            float[][] l = new float[][] { spectrum[0], t[i] };
            ds = new XYSeriesCollection(new SpectrumXYSeries("level " + (i + 1), l, rangeSpectrum));
            ds.setIntervalWidth(0.0);
            listMultipleCharts.add(ds);
        }
    } else if (mode.startsWith("haar")) {
        int l = Integer.parseInt(mode.substring(4));
        listMultipleCharts = new LinkedList<XYSeriesCollection>();

        float[] t1 = Haar.transform(spectrum[1], l);
        float[] t2 = Haar.transform(t1, l);
        XYSeriesCollection ds = new XYSeriesCollection(
                new SpectrumXYSeries("spectrum", spectrum, rangeSpectrum));
        ds.setIntervalWidth(0.0);
        listMultipleCharts.add(ds);
        XYSeriesCollection ds1 = new XYSeriesCollection(
                new SpectrumXYSeries(mode, new float[][] { spectrum[0], t1 }, rangeSpectrum));
        ds1.setIntervalWidth(0.0);
        listMultipleCharts.add(ds1);
        XYSeriesCollection ds2 = new XYSeriesCollection(
                new SpectrumXYSeries(mode, new float[][] { spectrum[0], t2 }, rangeSpectrum));
        ds2.setIntervalWidth(0.0);
        listMultipleCharts.add(ds2);
    } else if ("peaks".equals(mode) || "threshold peaks".equals(mode)) {
        double noise = 0.1; //"peaks".equals(mode) ? 2.0 : 1.0; // Spectrum.Noise(spectrum[1], 0, spectrum[1].length);
        int[] peakList = Spectrum.PickPeakIndexes(spectrum[1], noise);

        float[][] peaks = new float[2][peakList.length];
        for (int i = 0; i < peakList.length; i++) {
            int p = peakList[i];
            if (p >= spectrum[0].length)
                continue;
            peaks[0][i] = spectrum[0][p];
            peaks[1][i] = spectrum[1][p];
        }
        series.addSeries(new SpectrumXYSeries("|peaks", peaks, rangeSpectrum));
        _spectrum = peaks;
    } else if ("wavelet peaks".equals(mode)) {
        //Spectrum.Peak[] peaks = Spectrum.WaveletPeaks(spectrum);
        Spectrum.Peak[] peaks = Spectrum.WaveletPeaksD3(spectrum);
        float[][] peakSpectrum = new float[2][peaks.length];
        for (int p = 0; p < peaks.length; p++) {
            peakSpectrum[0][p] = peaks[p].mz;
            peakSpectrum[1][p] = peaks[p].intensity;
        }

        // show d3 and thresholded spectrum
        int levels = 3, N = spectrum[0].length;
        Filter f = new Filter("haar");
        float[][] modwt = Transform.decompose(spectrum[1], N, levels, f, "modwt", "periodic", null);
        float[][] mra = Transform.multiresolution(modwt, N, levels, f, "modwt", "periodic", null);
        float[] thresholded = new float[N];
        for (int i = 0; i < N; i++)
            thresholded[i] = mra[2][i] + mra[3][i];

        series.removeAllSeries();
        //series.addSeries(new SpectrumXYSeries("-spectrum", new float[][] {spectrum[0],thresholded}, rangeSpectrum));
        series.addSeries(new SpectrumXYSeries("-mra", new float[][] { spectrum[0], mra[2] }, rangeSpectrum));
        series.addSeries(new SpectrumXYSeries("|peaks", peakSpectrum, rangeSpectrum));
        _spectrum = peakSpectrum;
    }

    //
    // now update or create chart
    //

    Color[] colors = series.getSeriesCount() == 3 ? new Color[] { Color.RED, Color.BLUE, Color.BLUE }
            : series.getSeriesCount() == 2 ? new Color[] { Color.BLUE, Color.RED } : new Color[] { Color.RED };

    // NOTE: the more often we call setDatasets instead of creating new chart the better
    // CONSIDER: if we don't save chart, at least preserve zoom settings
    if (false && _chart != null && _chartPanel != null && !(_chart.getPlot() instanceof CombinedDomainXYPlot)
            && listMultipleCharts == null) {
        SpectrumChartFactory.setColors(_chartPanel, colors);
        _chart.getXYPlot().setDataset(series);
        _chartPanel.updateUI();
    } else {
        if (listMultipleCharts == null) {
            _log.debug(
                    "updateChart: series=" + series.getSeriesCount() + " length(0)=" + series.getItemCount(0));
            _chartPanel = SpectrumChartFactory.CreateChartPanel(series, colors);
        } else {
            _log.debug("updateChart: charts=" + listMultipleCharts.size());
            _chartPanel = SpectrumChartFactory.CreateChartPanel(listMultipleCharts, colors);
        }
        _chart = _chartPanel.getChart();

        // there seem to be mystery margins so give a little extra space
        Dimension size = chartArea.getSize();
        _chartPanel.setPreferredSize(new Dimension(size.width - 10, size.height - 10));
        chartArea.removeAll();
        chartArea.add(_chartPanel);
        chartArea.doLayout();
    }
    if (null != domainRange)
        _chart.getXYPlot().getDomainAxis().setRange(domainRange);

    //dhmay: if the user has locked the Y axis, then try to use the stored Y axis range
    if (isYAxisLocked()) {
        //a locked axis value won't be available if the axis was _just_ locked
        if (null == _lockedYAxisRange) {
            //if we've already displayed a chart, use that chart's axis range.  Otherwise,
            //don't force, and record this chart's axis range
            if (_previousYAxisRange != null)
                _lockedYAxisRange = _previousYAxisRange;
            else
                _lockedYAxisRange = _chart.getXYPlot().getRangeAxis().getRange();
        }
        _chart.getXYPlot().getRangeAxis().setRange(_lockedYAxisRange);
    } else {
        //if the Y axis isn't locked, then dump the stored range so it isn't used later
        _lockedYAxisRange = null;
    }

    //always store the previous Y axis range
    if (_chart.getXYPlot() != null && _chart.getXYPlot().getRangeAxis() != null
            && _chart.getXYPlot().getRangeAxis().getRange() != null) {
        _previousYAxisRange = _chart.getXYPlot().getRangeAxis().getRange();
    }

    ApplicationContext.setProperty(SharedProperties.CHART_RANGE, chartRange);
}