Example usage for org.jfree.data.category DefaultCategoryDataset addValue

List of usage examples for org.jfree.data.category DefaultCategoryDataset addValue

  1. HOME
  2. Java
  3. org.jfree
  4. org.jfree.data.category.*
  5. DefaultCategoryDataset
  6. addValue

Introduction

In this page you can find the example usage for org.jfree.data.category DefaultCategoryDataset addValue.

Prototype

public void addValue(double value, Comparable rowKey, Comparable columnKey)

Source Link

Document

Adds a value to the table.

Usage

From source file:NovoClass.java

public static void main(String[] args) {
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();

    dataset.addValue(10.1, "Maximo", "Hora 1");
    dataset.addValue(20.1, "Maximo", "Hora 2");
    dataset.addValue(30.1, "Maximo", "Hora 3");
    dataset.addValue(40.1, "Maximo", "Hora 4");
    dataset.addValue(70.1, "Maximo", "Hora 5");

    JFreeChart chart = ChartFactory.createLineChart("Grafico Simpes", "Hora", "Valor", dataset,
            PlotOrientation.HORIZONTAL, true, true, false);

    try {//from   w  ww  . jav  a  2  s.c  om
        System.out.println("Criando...");
        OutputStream png = new FileOutputStream("GraficoSimples.png");
        ChartUtilities.writeChartAsPNG(png, chart, 500, 400);
        png.close();
    } catch (Exception e) {
    }
}

From source file:edu.uara.wrappers.customcharts.CustomLineChart.java

public static void main(String[] args) {
    // create a dataset...
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    dataset.addValue(1.0, "Row 1", "Column 1");
    dataset.addValue(5.0, "Row 1", "Column 2");
    dataset.addValue(3.0, "Row 1", "Column 3");
    dataset.addValue(2.0, "Row 2", "Column 1");
    dataset.addValue(3.0, "Row 2", "Column 2");
    dataset.addValue(2.0, "Row 2", "Column 3");
    // create a chart...
    ILineChart c = new CustomLineChart("Test Line chart", "Domain", "Range", PlotOrientation.VERTICAL, true);
    c.generateLineChart(dataset);//w ww . j a  v a2s  . co m
    c.setBackGroundColor(Color.white);
    c.setPlotBackGroundColor(Color.white);
    c.drawChart("Chart Editor");
}

From source file:edu.uara.wrappers.customcharts.CustomBarChart.java

public static void main(String[] args) {
    // create a dataset...
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    dataset.addValue(1.0, "Row 1", "Column 1");
    dataset.addValue(5.0, "Row 1", "Column 2");
    dataset.addValue(3.0, "Row 1", "Column 3");
    dataset.addValue(2.0, "Row 2", "Column 1");
    dataset.addValue(3.0, "Row 2", "Column 2");
    dataset.addValue(2.0, "Row 2", "Column 3");
    // create a chart...
    IBarChart c = new CustomBarChart("Test barchart", "Domain", "Range", PlotOrientation.VERTICAL, true);
    c.generate3DStackedBarChart(dataset);
    c.drawChart("Chart Editor");
}

From source file:mzmatch.ipeak.normalisation.VanDeSompele.java

public static void main(String args[]) {
    try {//from www  .j  a  v  a 2 s. com
        Tool.init();

        // parse the commandline options
        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
        {
            // if the output directories do not exist, create them
            if (options.output != null)
                Tool.createFilePath(options.output, true);
        }

        // load the data
        if (options.verbose)
            System.out.println("Loading data");
        ParseResult result = PeakMLParser.parse(new FileInputStream(options.input), true);

        Header header = result.header;
        IPeakSet<IPeakSet<? extends IPeak>> peaksets = (IPeakSet<IPeakSet<? extends IPeak>>) result.measurement;

        int nrmeasurements = header.getNrMeasurementInfos();

        // remove the stability factor annotation
        for (IPeak peak : peaksets)
            peak.removeAnnotation("stability factor");

        // load the database
        if (options.verbose)
            System.out.println("Loading the molecule database");
        HashMap<String, Molecule> database = MoleculeIO.parseXml(new FileInputStream(options.database));

        // filter the set to include only identifiable metabolites
        if (options.verbose)
            System.out.println("Creating selection");
        Vector<IPeakSet<? extends IPeak>> selection = new Vector<IPeakSet<? extends IPeak>>();
        for (Molecule molecule : database.values()) {
            double mass = molecule.getMass(Mass.MONOISOTOPIC);
            double delta = PeriodicTable.PPM(mass, options.ppm);

            // get the most intense peak containing all the measurements
            Vector<IPeakSet<? extends IPeak>> neighbourhoud = peaksets.getPeaksInMassRange(mass - delta,
                    mass + delta);
            Collections.sort(neighbourhoud, IPeak.sort_intensity_descending);
            for (IPeakSet<? extends IPeak> neighbour : neighbourhoud)
                if (count(neighbour) == nrmeasurements) {
                    selection.add(neighbour);
                    break;
                }
        }

        // calculate the stability factor for each peak in the selection
        if (options.verbose)
            System.out.println("Calculating stability factors");
        for (int peakid1 = 0; peakid1 < selection.size(); ++peakid1) {
            double stddeviations[] = new double[selection.size()];

            IPeakSet<? extends IPeak> peakset1 = selection.get(peakid1);
            for (int peakid2 = 0; peakid2 < selection.size(); ++peakid2) {
                IPeakSet<? extends IPeak> peakset2 = selection.get(peakid2);

                double values[] = new double[nrmeasurements];
                for (int measurementid = 0; measurementid < nrmeasurements; ++measurementid) {
                    int measurementid1 = peakset1.get(measurementid).getMeasurementID();
                    int setid1 = header.indexOfSetInfo(header.getSetInfoForMeasurementID(measurementid1));
                    int measurementid2 = peakset2.get(measurementid).getMeasurementID();
                    int setid2 = header.indexOfSetInfo(header.getSetInfoForMeasurementID(measurementid2));
                    if (setid1 != setid2 || measurementid1 != measurementid2)
                        System.err.println("[WARNING]: differing setid or spectrumid for comparison");

                    values[measurementid] = Math.log(peakset1.get(measurementid).getIntensity()
                            / peakset2.get(measurementid).getIntensity()) / Math.log(2);
                }
                stddeviations[peakid2] = Statistical.stddev(values);
            }

            peakset1.addAnnotation("stability factor", Statistical.mean(stddeviations));
        }

        // sort on the stability factor
        Collections.sort(selection, new IPeak.AnnotationAscending("stability factor"));

        // take the top 10% and calculate the geometric mean
        if (options.verbose)
            System.out.println("Calculating normalisation factors");
        int nrselected = (int) (0.1 * selection.size());
        if (nrselected < 10)
            nrselected = (10 < selection.size() ? 10 : selection.size());
        double normalization_factors[] = new double[nrmeasurements];
        for (int measurementid = 0; measurementid < nrmeasurements; ++measurementid) {
            double values[] = new double[nrselected];
            for (int i = 0; i < nrselected; ++i) {
                IPeak peak = selection.get(i).get(measurementid);
                values[i] = peak.getIntensity();
            }
            normalization_factors[measurementid] = Statistical.geomean(values);
        }

        // scale the found normalization factors
        double maxnf = Statistical.max(normalization_factors);
        for (int sampleid = 0; sampleid < nrmeasurements; ++sampleid)
            normalization_factors[sampleid] /= maxnf;

        // write the selection if needed
        if (options.selection != null) {
            if (options.verbose)
                System.out.println("Writing original selection data");

            PeakMLWriter.write(result.header, selection, null,
                    new GZIPOutputStream(new FileOutputStream(options.selection)), null);
        }

        // normalize all the peaks
        if (options.verbose)
            System.out.println("Normalizing all the entries");
        for (IPeakSet<? extends IPeak> peakset : peaksets) {
            for (int measurementid = 0; measurementid < nrmeasurements; ++measurementid) {
                // TODO why did I do this again ?
                int id = 0;
                int setid = 0;
                int spectrumid = 0;
                for (int i = 0; i < header.getNrSetInfos(); ++i) {
                    SetInfo set = header.getSetInfos().get(i);

                    if (id + set.getNrMeasurementIDs() > measurementid) {
                        setid = i;
                        spectrumid = measurementid - id;
                        break;
                    } else
                        id += set.getNrMeasurementIDs();
                }

                MassChromatogram<Peak> masschromatogram = null;
                for (IPeak p : peakset) {
                    int mymeasurementid = p.getMeasurementID();
                    int mysetid = header.indexOfSetInfo(header.getSetInfoForMeasurementID(mymeasurementid));
                    if (mysetid == setid && mymeasurementid == spectrumid) {
                        masschromatogram = (MassChromatogram<Peak>) p;
                        break;
                    }
                }
                if (masschromatogram == null)
                    continue;

                for (IPeak peak : masschromatogram.getPeaks())
                    peak.setIntensity(peak.getIntensity() / normalization_factors[measurementid]);
            }
        }

        // write the selection if needed
        if (options.selection_normalized != null) {
            if (options.verbose)
                System.out.println("Writing the normalized selection data");

            PeakMLWriter.write(result.header, selection, null,
                    new GZIPOutputStream(new FileOutputStream(options.selection_normalized)), null);
        }

        // write the factors if needed
        if (options.factors != null) {
            if (options.verbose)
                System.out.println("Writing the normalization factors");

            PrintStream out = new PrintStream(options.factors);
            for (int measurementid = 0; measurementid < nrmeasurements; ++measurementid)
                out.println(header.getMeasurementInfo(measurementid).getLabel() + "\t"
                        + normalization_factors[measurementid]);
        }

        // write the plot if needed
        if (options.img != null) {
            if (options.verbose)
                System.out.println("Writing the graph");

            DefaultCategoryDataset dataset = new DefaultCategoryDataset();
            JFreeChart linechart = ChartFactory.createLineChart(null, "measurement", "normalization factor",
                    dataset, PlotOrientation.VERTICAL, false, // legend
                    false, // tooltips
                    false // urls
            );

            CategoryPlot plot = (CategoryPlot) linechart.getPlot();
            CategoryAxis axis = (CategoryAxis) plot.getDomainAxis();
            axis.setCategoryLabelPositions(CategoryLabelPositions.UP_45);
            LineAndShapeRenderer renderer = (LineAndShapeRenderer) plot.getRenderer();

            renderer.setSeriesShapesFilled(0, true);
            renderer.setSeriesShapesVisible(0, true);

            linechart.setBackgroundPaint(Color.WHITE);
            linechart.setBorderVisible(false);
            linechart.setAntiAlias(true);

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

            // create the datasets
            for (int measurementid = 0; measurementid < nrmeasurements; ++measurementid)
                dataset.addValue(normalization_factors[measurementid], "",
                        header.getMeasurementInfo(measurementid).getLabel());
            JFreeChartTools.writeAsPDF(new FileOutputStream(options.img), linechart, 800, 500);
        }

        // write the normalized values
        if (options.verbose)
            System.out.println("Writing the normalized data");
        PeakMLWriter.write(result.header, peaksets.getPeaks(), null,
                new GZIPOutputStream(new FileOutputStream(options.output)), null);
    } catch (Exception e) {
        Tool.unexpectedError(e, application);
    }
}

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

private static CategoryDataset createDataset() {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    defaultcategorydataset.addValue(143.19999999999999D, "S1", "C1");
    defaultcategorydataset.addValue(120.2D, "S1", "C2");
    defaultcategorydataset.addValue(135D, "S1", "C3");
    defaultcategorydataset.addValue(115D, "S1", "C4");
    defaultcategorydataset.addValue(98.700000000000003D, "S2", "C1");
    defaultcategorydataset.addValue(63.200000000000003D, "S2", "C2");
    defaultcategorydataset.addValue(71.400000000000006D, "S2", "C3");
    defaultcategorydataset.addValue(55D, "S2", "C4");
    return defaultcategorydataset;
}

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

private static CategoryDataset createDataset() {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    defaultcategorydataset.addValue(21D, "Series 1", "Category 1");
    defaultcategorydataset.addValue(50D, "Series 1", "Category 2");
    defaultcategorydataset.addValue(152D, "Series 1", "Category 3");
    defaultcategorydataset.addValue(184D, "Series 1", "Category 4");
    defaultcategorydataset.addValue(299D, "Series 1", "Category 5");
    return defaultcategorydataset;
}

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

private static CategoryDataset createDataset() {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    defaultcategorydataset.addValue(51D, "Series 1", "Apples");
    defaultcategorydataset.addValue(44.299999999999997D, "Series 1", "Bananas");
    defaultcategorydataset.addValue(93D, "Series 1", "Oranges");
    defaultcategorydataset.addValue(35.600000000000001D, "Series 1", "Pears");
    defaultcategorydataset.addValue(75.099999999999994D, "Series 1", "Plums");
    return defaultcategorydataset;
}

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

private static CategoryDataset createDataset() {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    defaultcategorydataset.addValue(212D, "Classes", "JDK 1.0");
    defaultcategorydataset.addValue(504D, "Classes", "JDK 1.1");
    defaultcategorydataset.addValue(1520D, "Classes", "SDK 1.2");
    defaultcategorydataset.addValue(1842D, "Classes", "SDK 1.3");
    defaultcategorydataset.addValue(2991D, "Classes", "SDK 1.4");
    return defaultcategorydataset;
}

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

private static CategoryDataset createDataset() {
    String s = "First";
    String s1 = "Second";
    String s2 = "Third";
    String s3 = "Category 1";
    String s4 = "Category 2";
    String s5 = "Category 3";
    String s6 = "Category 4";
    String s7 = "Category 5";
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    dataset.addValue(1.0D, s, s3);
    dataset.addValue(4D, s, s4);//from   w  w  w  .  ja v  a  2s . c  om
    dataset.addValue(3D, s, s5);
    dataset.addValue(5D, s, s6);
    dataset.addValue(5D, s, s7);
    dataset.addValue(5D, s1, s3);
    dataset.addValue(7D, s1, s4);
    dataset.addValue(6D, s1, s5);
    dataset.addValue(8D, s1, s6);
    dataset.addValue(4D, s1, s7);
    dataset.addValue(4D, s2, s3);
    dataset.addValue(3D, s2, s4);
    dataset.addValue(2D, s2, s5);
    dataset.addValue(3D, s2, s6);
    dataset.addValue(6D, s2, s7);
    return dataset;
}

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

private static CategoryDataset createDataset() {
    DefaultCategoryDataset defaultcategorydataset = new DefaultCategoryDataset();
    defaultcategorydataset.addValue(32.399999999999999D, "Series 1", "Category 1");
    defaultcategorydataset.addValue(17.800000000000001D, "Series 2", "Category 1");
    defaultcategorydataset.addValue(27.699999999999999D, "Series 3", "Category 1");
    defaultcategorydataset.addValue(43.200000000000003D, "Series 1", "Category 2");
    defaultcategorydataset.addValue(15.6D, "Series 2", "Category 2");
    defaultcategorydataset.addValue(18.300000000000001D, "Series 3", "Category 2");
    defaultcategorydataset.addValue(23D, "Series 1", "Category 3");
    defaultcategorydataset.addValue(111.3D, "Series 2", "Category 3");
    defaultcategorydataset.addValue(25.5D, "Series 3", "Category 3");
    defaultcategorydataset.addValue(13D, "Series 1", "Category 4");
    defaultcategorydataset.addValue(11.800000000000001D, "Series 2", "Category 4");
    defaultcategorydataset.addValue(29.5D, "Series 3", "Category 4");
    return defaultcategorydataset;
}