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

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

Introduction

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

Prototype

public void setSeriesShapesVisible(int series, Boolean flag) 

Source Link

Document

Sets the 'shapes visible' flag for a series and sends a RendererChangeEvent to all registered listeners.

Usage

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 .co 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:org.gephi.statistics.plugin.DegreeDistribution.java

/**
 *
 * @return The directed version of the report.
 *///w  w w. j a va2s  . co m
private String getDirectedReport() {
    double inMax = 0;
    XYSeries inSeries2 = new XYSeries("Series 2");
    for (int i = 1; i < inDistribution[1].length; i++) {
        if (inDistribution[1][i] > 0) {
            inSeries2.add((Math.log(inDistribution[0][i]) / Math.log(Math.E)),
                    (Math.log(inDistribution[1][i]) / Math.log(Math.E)));
            inMax = (float) Math.max((Math.log(inDistribution[0][i]) / Math.log(Math.E)), inMax);
        }
    }
    double inA = inAlpha;
    double inB = inBeta;

    String inImageFile = "";
    String outImageFile = "";
    try {

        XYSeries inSeries1 = new XYSeries(inAlpha + " ");
        inSeries1.add(0, inA);
        inSeries1.add(inMax, inA + inB * inMax);

        XYSeriesCollection inDataset = new XYSeriesCollection();
        inDataset.addSeries(inSeries1);
        inDataset.addSeries(inSeries2);

        JFreeChart inChart = ChartFactory.createXYLineChart("In-Degree Distribution", "In-Degree", "Occurrence",
                inDataset, PlotOrientation.VERTICAL, true, false, false);
        XYPlot inPlot = (XYPlot) inChart.getPlot();
        XYLineAndShapeRenderer inRenderer = new XYLineAndShapeRenderer();
        inRenderer.setSeriesLinesVisible(0, true);
        inRenderer.setSeriesShapesVisible(0, false);
        inRenderer.setSeriesLinesVisible(1, false);
        inRenderer.setSeriesShapesVisible(1, true);
        inRenderer.setSeriesShape(1, new java.awt.geom.Ellipse2D.Double(0, 0, 1, 1));
        inPlot.setBackgroundPaint(java.awt.Color.WHITE);
        inPlot.setDomainGridlinePaint(java.awt.Color.GRAY);
        inPlot.setRangeGridlinePaint(java.awt.Color.GRAY);

        inPlot.setRenderer(inRenderer);

        final ChartRenderingInfo info = new ChartRenderingInfo(new StandardEntityCollection());

        TempDir tempDir = TempDirUtils.createTempDir();
        final String fileName = "inDistribution.png";
        final File file1 = tempDir.createFile(fileName);
        inImageFile = "<IMG SRC=\"file:" + file1.getAbsolutePath() + "\" "
                + "WIDTH=\"600\" HEIGHT=\"400\" BORDER=\"0\" USEMAP=\"#chart\"></IMG>";
        ChartUtilities.saveChartAsPNG(file1, inChart, 600, 400, info);

        double outMax = 0;
        XYSeries outSeries2 = new XYSeries("Series 2");
        for (int i = 1; i < outDistribution[1].length; i++) {
            if (outDistribution[1][i] > 0) {
                outSeries2.add((Math.log(outDistribution[0][i]) / Math.log(Math.E)),
                        (Math.log(outDistribution[1][i]) / Math.log(Math.E)));
                outMax = (float) Math.max((Math.log(outDistribution[0][i]) / Math.log(Math.E)), outMax);
            }
        }
        double outA = outAlpha;
        double outB = outBeta;

        XYSeries outSeries1 = new XYSeries(outAlpha + " ");
        outSeries1.add(0, outA);
        outSeries1.add(outMax, outA + outB * outMax);

        XYSeriesCollection outDataset = new XYSeriesCollection();
        outDataset.addSeries(outSeries1);
        outDataset.addSeries(outSeries2);

        JFreeChart outchart = ChartFactory.createXYLineChart("Out-Degree Distribution", "Out-Degree",
                "Occurrence", outDataset, PlotOrientation.VERTICAL, true, false, false);
        XYPlot outPlot = (XYPlot) outchart.getPlot();
        XYLineAndShapeRenderer outRenderer = new XYLineAndShapeRenderer();
        outRenderer.setSeriesLinesVisible(0, true);
        outRenderer.setSeriesShapesVisible(0, false);
        outRenderer.setSeriesLinesVisible(1, false);
        outRenderer.setSeriesShapesVisible(1, true);
        outRenderer.setSeriesShape(1, new java.awt.geom.Ellipse2D.Double(0, 0, 1, 1));
        outPlot.setBackgroundPaint(java.awt.Color.WHITE);
        outPlot.setDomainGridlinePaint(java.awt.Color.GRAY);
        outPlot.setRangeGridlinePaint(java.awt.Color.GRAY);

        outPlot.setRenderer(outRenderer);

        final ChartRenderingInfo info2 = new ChartRenderingInfo(new StandardEntityCollection());
        final String fileName2 = "outDistribution.png";
        final File file2 = tempDir.createFile(fileName2);
        outImageFile = "<IMG SRC=\"file:" + file2.getAbsolutePath() + "\" "
                + "WIDTH=\"600\" HEIGHT=\"400\" BORDER=\"0\" USEMAP=\"#chart\"></IMG>";
        ChartUtilities.saveChartAsPNG(file2, outchart, 600, 400, info2);
    } catch (IOException e) {
        Exceptions.printStackTrace(e);
    }

    String report = "<HTML> <BODY> <h1>Degree Distribution Metric Report </h1> " + "<hr>" + "<br>"
            + "<h2> Parameters: </h2>" + "Network Interpretation:  " + (isDirected ? "directed" : "undirected")
            + "<br>" + "<br> <h2> Results: </h2>" + "In-Degree Power Law: -" + inAlpha + "\n <BR>" + inImageFile
            + "<br>Out-Degree Power Law: -" + outAlpha + "\n <BR>" + outImageFile + "</BODY> </HTML>";

    return report;
}

From source file:oct.analysis.application.OCTSelection.java

public JPanel createLRPPanel() {
    //create the series collection from the LRP data
    XYSeriesCollection lrp = new XYSeriesCollection();
    lrp.addSeries(getLrpSeriesFromOCT(OCTAnalysisManager.getInstance().getOctImage()));
    //        System.out.println("Processing graph " + lrp.getSeriesKey(0).toString());
    lrp.addSeries(findMaximums(lrp.getSeries(0), selectionName + " LRP Maximums"));
    List<XYSeries> fwhm = getFWHMForLRPPeaks(lrp.getSeries(1), lrp.getSeries(0));
    fwhm.forEach((fwhmSeries) -> {//from  w  w  w  .j  a v a 2  s .  c o m
        lrp.addSeries(fwhmSeries);
    });
    //create chart panel for LRP
    JFreeChart chart = ChartFactory.createXYLineChart(lrp.getSeriesKey(0).toString(), "Pixel Height",
            "Reflectivity", lrp, PlotOrientation.HORIZONTAL, false, true, false);
    XYPlot plot = chart.getXYPlot();
    //        plot.setRangeAxisLocation(AxisLocation.TOP_OR_LEFT);
    //        plot.getDomainAxis().setInverted(true);
    //set up rendering principles
    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
    renderer.setSeriesLinesVisible(0, true);
    renderer.setSeriesShapesVisible(0, false);
    renderer.setSeriesPaint(0, Color.RED);
    renderer.setSeriesLinesVisible(1, false);
    renderer.setSeriesShapesVisible(1, true);
    renderer.setSeriesShapesFilled(1, true);
    renderer.setSeriesPaint(1, Color.BLUE);
    for (int i = 2; i < fwhm.size() + 2; i++) {
        renderer.setSeriesLinesVisible(i, true);
        renderer.setSeriesShapesVisible(i, false);
        renderer.setSeriesPaint(i, Color.BLACK);
    }
    plot.setRenderer(renderer);
    //make panel
    ChartPanel panel = new ChartPanel(chart);
    panel.setPreferredSize(new Dimension(200, 200));
    panel.setFillZoomRectangle(true);
    panel.setMouseWheelEnabled(true);
    return panel;
}

From source file:com.haskins.cloudtrailviewer.feature.MetricsFeature.java

private void showChart(String service) {

    final TimeSeriesCollection chartData = generateTimeSeriesData(service);

    JFreeChart chart = ChartFactory.createTimeSeriesChart(service, "Time", "Calls", chartData, false, true,
            false);/*from w  ww . j  av  a2  s.  c  om*/

    // draw outter line
    XYLineAndShapeRenderer lineAndShapeRenderer = new XYLineAndShapeRenderer();
    lineAndShapeRenderer.setPaint(new Color(64, 168, 228, 75));
    lineAndShapeRenderer.setSeriesShape(0, new Ellipse2D.Double(-3, -3, 6, 6));
    lineAndShapeRenderer.setSeriesShapesFilled(0, true);
    lineAndShapeRenderer.setSeriesShapesVisible(0, true);
    lineAndShapeRenderer.setUseOutlinePaint(true);
    lineAndShapeRenderer.setUseFillPaint(true);

    // draw filled area
    XYAreaRenderer renderer = new XYAreaRenderer();
    renderer.setPaint(new Color(64, 168, 228, 50));

    // configure Plot
    final XYPlot plot = chart.getXYPlot();
    plot.setBackgroundPaint(Color.WHITE);
    plot.setOutlineVisible(false);

    plot.setDataset(0, chartData);
    plot.setDataset(1, chartData);

    plot.setRenderer(0, lineAndShapeRenderer);
    plot.setRenderer(1, renderer);

    plot.getDomainAxis().setLowerMargin(0);
    plot.getDomainAxis().setUpperMargin(0);

    // format chart title
    TextTitle t = chart.getTitle();
    t.setFont(new Font("Arial", Font.BOLD, 14));

    // Cross Hairs
    xCrosshair = new Crosshair(Double.NaN, Color.GRAY, new BasicStroke(0f));
    xCrosshair.setLabelVisible(true);
    xCrosshair.setLabelGenerator(new DateTimeCrosshairLabelGenerator());

    CrosshairOverlay crosshairOverlay = new CrosshairOverlay();
    crosshairOverlay.addDomainCrosshair(xCrosshair);

    // Create the panel
    chartPanel = new ChartPanel(chart);
    chartPanel.setMinimumDrawWidth(0);
    chartPanel.setMaximumDrawWidth(Integer.MAX_VALUE);
    chartPanel.setMinimumDrawHeight(0);
    chartPanel.setMaximumDrawHeight(Integer.MAX_VALUE);
    chartPanel.setMouseZoomable(true, false);
    chartPanel.setDomainZoomable(true);
    chartPanel.setRangeZoomable(false);
    chartPanel.addChartMouseListener(this);
    chartPanel.addOverlay(crosshairOverlay);

    // update the display
    chartCards.removeAll();
    chartCards.add(chartPanel, "");
    chartCards.revalidate();
}

From source file:com.kodemore.freechart.KmSimpleLineChart.java

private JFreeChart createChart(XYDataset dataset) {
    PlotOrientation orientation = PlotOrientation.VERTICAL;

    boolean showsTooltips = false;
    boolean showsUrls = false;

    JFreeChart chart = ChartFactory.createXYLineChart(getTitle(), getAxisTitleX(), getAxisTitleY(), dataset,
            orientation, getShowsLegend(), showsTooltips, showsUrls);

    if (hasBackgroundColor())
        chart.setBackgroundPaint(getBackgroundColor());

    XYPlot plot;/*from   w w  w .j ava  2s . co  m*/
    plot = chart.getXYPlot();

    if (hasPlotBackgroundColor())
        plot.setBackgroundPaint(getPlotBackgroundColor());

    if (hasPlotGridLineColor()) {
        Color color = getPlotGridLineColor();
        plot.setDomainGridlinePaint(color);
        plot.setRangeGridlinePaint(color);
    }

    XYLineAndShapeRenderer renderer;
    renderer = new XYLineAndShapeRenderer();

    KmList<KmSimpleLineChartGroup> groups = getGroups();
    int n = groups.size();
    for (int i = 0; i < n; i++) {
        KmSimpleLineChartGroup group = groups.getAt(i);

        renderer.setSeriesLinesVisible(i, group.getShowsLines());
        renderer.setSeriesShapesVisible(i, group.getShowsShapes());
    }

    plot.setRenderer(renderer);

    if (getIntegerUnitsX()) {
        NumberAxis rangeAxis;
        rangeAxis = (NumberAxis) plot.getRangeAxis();
        rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
    }

    if (getIntegerUnitsY()) {
        NumberAxis rangeAxis;
        rangeAxis = (NumberAxis) plot.getDomainAxis();
        rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
    }

    return chart;
}

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.  jav  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));
    }

}

From source file:regresiones.RegresionSimple.java

public void Resolver(JTabbedPane resultados) {

    for (int i = 0; i < 9; i++) {
        sumatorias[i] = 0.0;//w w  w  .  j  a  va 2s . c  o  m
    }
    try {
        System.out.println("TOTAL DE DATOS: " + N);
        for (int i = 0; i < N; i++) {
            xiyi[i] = datos[i][0] * datos[i][1];
            System.out.println("X*Y" + i + ": " + xiyi[i]);
            x2[i] = datos[i][0] * datos[i][0]; //elevamos al cuadrado las x's
            y2[i] = datos[i][1] * datos[i][1]; //elevamos al cuadrado las y's
            sumatorias[0] += datos[i][0]; //sumatoria de x
            sumatorias[1] += datos[i][1]; //sumatoria de y

        }
        //sumatoria de xi*yi
        for (int j = 0; j < N; j++) {
            sumatorias[2] += xiyi[j];
        }

        //sumatoria de x^2
        for (int j = 0; j < N; j++) {
            sumatorias[3] += x2[j];
        }

        //sumatoria de y^2
        for (int j = 0; j < N; j++) {
            sumatorias[4] += y2[j];
        }

        mediax = sumatorias[0] / N;
        mediay = sumatorias[1] / N;

        System.out.println("RAIS 25: " + Math.sqrt(25));

        DecimalFormat df = new DecimalFormat("##.##");
        df.setRoundingMode(RoundingMode.DOWN);
        System.out.println("redondeo x^2-- " + df.format(sumatorias[3]));
        System.out.println("redondeo y^2-- " + df.format(sumatorias[4]));
        redondeoSumatoriax2 = Double.parseDouble(df.format(sumatorias[3]));
        redondeoSumatoriay2 = Double.parseDouble(df.format(sumatorias[4]));
        dxy = ((sumatorias[2]) / N) - mediax * mediay;
        dy = Math.sqrt(((redondeoSumatoriay2 / N) - (mediay * mediay)));
        dx = Math.sqrt(((redondeoSumatoriax2 / N) - (mediax * mediax)));

        b1 = ((sumatorias[2] * N) - sumatorias[0] * sumatorias[1])
                / ((sumatorias[3] * N) - (sumatorias[0] * sumatorias[0]));
        b0 = (sumatorias[1] / N) - ((b1 * sumatorias[0]) / N);

        // Y ESTIMADA
        for (int i = 0; i < N; i++) {
            yEstimada[i] = b0 + (b1 * datos[i][0]);
        }

        Se = Math.sqrt((sumatorias[4] - (b0 * sumatorias[1]) - (b1 * sumatorias[2])) / (N - 2));
        r = dxy / (dx * dy);
        System.out.println("sum x: " + sumatorias[0]);
        System.out.println("sum y: " + sumatorias[1]);
        System.out.println("sum x*y: " + sumatorias[2]);
        System.out.println("sum x^2: " + sumatorias[3]);
        System.out.println("sum y^2: " + sumatorias[4]);
        System.out.println("DX7: " + dxy);
        System.out.println("DY: " + dy);
        System.out.println("DX: " + dx);
        System.out.println("B0: " + b0);
        System.out.println("B1: " + b1);

        // mostramos resultados para la pestaa resultados***********************************************************************
        JPanel panel = new JPanel(new BorderLayout());
        panel.setBackground(Color.white);
        JLabel titulo = new JLabel("Resultados");//creamos el titulo
        panel.add(titulo, BorderLayout.PAGE_START);//lo agregamos al inicio
        jtable = new JTable();//creamos la tabla a mostrar
        jtable.setBorder(new javax.swing.border.LineBorder(new java.awt.Color(255, 0, 0), 2, true));
        jtable.setFont(new java.awt.Font("Arial", 1, 14));
        jtable.setColumnSelectionAllowed(true);
        jtable.setCursor(new java.awt.Cursor(java.awt.Cursor.N_RESIZE_CURSOR));
        jtable.setInheritsPopupMenu(true);
        jtable.setMinimumSize(new java.awt.Dimension(80, 80));
        String[] titulos = { "X", "Y", "Xi*Yi", "X2", "Y2", "Y estimada" };//los titulos de la tabla
        arregloFinal = new String[N][6];
        DecimalFormat formato = new DecimalFormat("0.00");
        for (int i = 0; i < N; i++) {//armamos el arreglo
            arregloFinal[i][0] = datos[i][0] + ""; //X
            arregloFinal[i][1] = datos[i][1] + "";//Y
            arregloFinal[i][2] = formato.format(xiyi[i]);
            arregloFinal[i][3] = formato.format(x2[i]);
            arregloFinal[i][4] = formato.format(y2[i]);
            arregloFinal[i][5] = formato.format(yEstimada[i]);
        }
        DefaultTableModel TableModel = new DefaultTableModel(arregloFinal, titulos);
        jtable.setModel(TableModel);
        JScrollPane jScrollPane1 = new JScrollPane();
        jScrollPane1.setViewportView(jtable);
        jtable.getColumnModel().getSelectionModel()
                .setSelectionMode(javax.swing.ListSelectionModel.SINGLE_INTERVAL_SELECTION);

        panel.add(jScrollPane1, BorderLayout.CENTER);
        JPanel panel2 = new JPanel(new GridLayout(0, 4));//creo un panel con rejilla de 4 columnas
        JLabel etiquetaN = new JLabel("N");
        JTextField cajaN = new JTextField();
        cajaN.setText(N + "");
        JLabel etiquetab0 = new JLabel("b0");
        JTextField cajab0 = new JTextField();
        cajab0.setText(b0 + "");
        JLabel etiquetab1 = new JLabel("b1");
        JTextField cajab1 = new JTextField();
        cajab1.setText(b1 + "");
        JLabel etiquetadxy = new JLabel("DXy");
        JTextField cajadxy = new JTextField();
        cajadxy.setText(dxy + "");
        JLabel etiquetadx = new JLabel("DX");
        JTextField cajadx = new JTextField();
        cajadx.setText(dx + "");
        JLabel etiquetady = new JLabel("DY");
        JTextField cajady = new JTextField();
        cajady.setText(dy + "");
        JLabel etiquetaR = new JLabel("R");
        JTextField cajaR = new JTextField();
        cajaR.setText(r + "");
        JLabel etiquetaSE = new JLabel("SE");
        JTextField cajaSE = new JTextField();
        cajaSE.setText(Se + "");
        JButton boton = new JButton("Exportar a PDF");
        boton.addActionListener(this);
        panel2.add(etiquetaN);
        panel2.add(cajaN);
        panel2.add(etiquetab0);
        panel2.add(cajab0);
        panel2.add(etiquetab1);
        panel2.add(cajab1);
        panel2.add(etiquetadxy);
        panel2.add(cajadxy);
        panel2.add(etiquetadx);
        panel2.add(cajadx);
        panel2.add(etiquetady);
        panel2.add(cajady);
        panel2.add(etiquetaR);
        panel2.add(cajaR);
        panel2.add(etiquetaSE);
        panel2.add(cajaSE);
        panel2.add(boton);
        panel.add(panel2, BorderLayout.SOUTH);//agrego el panel2 con rejilla en el panel principal al sur
        resultados.addTab("resultado", panel);
        //**************************************************************************************
        //intervalos de confianza
        JPanel intervalos = new JPanel(new BorderLayout());
        JPanel variables = new JPanel(new GridLayout(0, 2));
        JLabel variableX1 = new JLabel("X1");
        cajaVariableX1 = new JTextField();
        boton = new JButton("calcular");
        boton.addActionListener(this);
        JLabel variableEfectividad = new JLabel("Efectividad");
        String[] efectividades = { "80", "85", "90", "95", "99" };
        combo = new JComboBox(efectividades);
        variables.add(variableX1);
        variables.add(cajaVariableX1);
        variables.add(variableEfectividad);
        variables.add(combo);
        variables.add(boton);//comentario
        //cometario2
        intervalos.add(variables, BorderLayout.NORTH);
        jtable2 = new JTable();//creamos la tabla a mostrar
        jtable2.setBorder(new javax.swing.border.LineBorder(new java.awt.Color(255, 0, 0), 2, true));
        jtable2.setFont(new java.awt.Font("Arial", 1, 14));
        jtable2.setColumnSelectionAllowed(true);
        jtable2.setCursor(new java.awt.Cursor(java.awt.Cursor.N_RESIZE_CURSOR));
        jtable2.setInheritsPopupMenu(true);
        jtable2.setMinimumSize(new java.awt.Dimension(80, 80));
        String[] titulos2 = { "Y estimada", "Li", "Ls" };//los titulos de la tabla
        String[][] pruebaIntervalos = { { "", "", "" } };
        DefaultTableModel TableModel2 = new DefaultTableModel(pruebaIntervalos, titulos2);
        jtable2.setModel(TableModel2);
        JScrollPane jScrollPane2 = new JScrollPane();
        jScrollPane2.setViewportView(jtable2);
        jtable2.getColumnModel().getSelectionModel()
                .setSelectionMode(javax.swing.ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        intervalos.add(jScrollPane2, BorderLayout.CENTER);
        resultados.addTab("intervalos", intervalos);
        // ***********************************************************************
        JPanel graficas = new JPanel(new GridLayout(0, 1));
        XYDataset dataset = createSampleDataset();
        JFreeChart chart = ChartFactory.createXYLineChart("Grafica", "X", "Y", dataset,
                PlotOrientation.VERTICAL, true, false, false);
        XYPlot plot = (XYPlot) chart.getPlot();
        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
        renderer.setSeriesLinesVisible(0, true);
        renderer.setSeriesShapesVisible(0, true);
        renderer.setSeriesLinesVisible(1, true);
        renderer.setSeriesShapesVisible(1, true);
        plot.setRenderer(renderer);
        final ChartPanel chartPanel = new ChartPanel(chart);
        chartPanel.setPreferredSize(new java.awt.Dimension(500, 300));
        graficas.add(chartPanel);//agregamos la primer grafica
        resultados.addTab("Graficas", graficas);
        //IMPRIMIR JTABLE
        /* MessageFormat headerFormat = new MessageFormat("MI CABECERA");
         MessageFormat footerFormat = new MessageFormat("- Pgina {0} -");
         jtable.print(PrintMode.FIT_WIDTH, headerFormat, footerFormat);
         */

    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:edu.ucla.stat.SOCR.chart.demo.PowerTransformQQNormalPlotChart.java

/**
 * Creates a chart./*from   ww w. j  av a2 s  .com*/
 * 
 * @param dataset  the data for the chart.
 * 
 * @return a chart.
 */
protected JFreeChart createChart(XYDataset dataset) {

    // create the chart...
    JFreeChart chart = ChartFactory.createXYLineChart(chartTitle, //"Power Tranfomed Normal Q-Q plot",      // chart title
            domainLabel, // x axis label
            rangeLabel, // y axis label
            dataset, // data
            PlotOrientation.VERTICAL, true, // include legend
            true, // tooltips
            false // urls
    );

    // NOW DO SOME OPTIONAL CUSTOMISATION OF THE CHART...
    chart.setBackgroundPaint(Color.white);

    // get a reference to the plot for further customisation...
    XYPlot plot = (XYPlot) chart.getPlot();
    plot.setBackgroundPaint(Color.white);
    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));
    plot.setDomainGridlinePaint(Color.lightGray);
    plot.setRangeGridlinePaint(Color.lightGray);

    XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) plot.getRenderer();
    // renderer.setShapesVisible(true);
    renderer.setBaseShapesFilled(true);
    //  renderer.setLinesVisible(false);
    renderer.setSeriesLinesVisible(1, true);
    renderer.setSeriesShapesVisible(1, false);
    renderer.setSeriesLinesVisible(2, true);
    renderer.setSeriesShapesVisible(2, true);
    renderer.setSeriesLinesVisible(0, false);
    renderer.setSeriesShapesVisible(0, true);

    //renderer.setLegendItemLabelGenerator(new SOCRXYSeriesLabelGenerator());

    // change the auto tick unit selection to integer units only...
    NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setAutoRangeIncludesZero(false);
    rangeAxis.setUpperMargin(0);
    rangeAxis.setLowerMargin(0);

    // rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
    NumberAxis domainAxis = (NumberAxis) plot.getDomainAxis();
    domainAxis.setAutoRangeIncludesZero(false);
    domainAxis.setUpperMargin(0);
    domainAxis.setLowerMargin(0);

    // domainAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());

    // OPTIONAL CUSTOMISATION COMPLETED.
    //setQQSummary(dataset);    // very confusing   
    return chart;

}

From source file:me.childintime.childintime.ui.window.tool.BmiToolDialog.java

/**
 * Creates a chart./* w w w  .j a v a2s  .  c om*/
 *
 * @param dataset  the data for the chart.
 *
 * @return a chart.
 */
private JFreeChart createChart(final XYDataset dataset) {
    // Create the chart
    final JFreeChart chart = ChartFactory.createXYLineChart("BMI chart", "Age", "Value", dataset,
            PlotOrientation.VERTICAL, true, true, false);

    // Set the background color to the LAF's default
    chart.setBackgroundPaint(new JPanel().getBackground());

    // get a reference to the plot for further customisation...
    final XYPlot plot = chart.getXYPlot();
    plot.setBackgroundPaint(Color.WHITE);
    plot.setDomainGridlinePaint(Color.lightGray);
    plot.setRangeGridlinePaint(Color.lightGray);

    final XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
    for (int i = 0; i < 3; i++) {
        renderer.setSeriesLinesVisible(i, true);
        renderer.setSeriesShapesVisible(i, true);
        renderer.setSeriesFillPaint(i, Color.RED);
    }
    plot.setRenderer(renderer);

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

    // change the auto tick unit selection to integer units only...
    final NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());

    return chart;
}

From source file:gov.nih.nci.caintegrator.plots.kaplanmeier.JFreeChartIKMPlottermpl.java

public JFreeChart createKMPlot(Collection<GroupCoordinates> groupsToBePlotted, String title, String xAxisLabel,
        String yAxisLabel) {// w  ww  .  j a  v a2s.  c  o  m
    List<KMPlotPointSeriesSet> kmPlotSets = new ArrayList<KMPlotPointSeriesSet>(
            convertToKaplanMeierPlotPointSeriesSet(groupsToBePlotted));

    XYSeriesCollection finalDataCollection = new XYSeriesCollection();
    /*  Repackage all the datasets to go into the XYSeriesCollection */
    for (KMPlotPointSeriesSet dataSet : kmPlotSets) {
        finalDataCollection.addSeries(dataSet.getCensorPlotPoints());
        finalDataCollection.addSeries(dataSet.getProbabilityPlotPoints());

    }

    JFreeChart chart = ChartFactory.createXYLineChart("", xAxisLabel, yAxisLabel, finalDataCollection,
            PlotOrientation.VERTICAL, true, //legend
            true, //tooltips
            false//urls
    );
    XYPlot plot = (XYPlot) chart.getPlot();
    /*
     * Ideally the actual Renderer settings should have been created
     * at the survivalLength of iterating KaplanMeierPlotPointSeriesSets, adding them to the actual
     * Data Set that is going to be going into the Chart plotter.  But you have no idea how
     * they are going to be sitting in the Plot dataset so there is no guarantee that setting the
     * renderer based on a supposed index will actually work. In fact
     */

    XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
    for (int i = 0; i < finalDataCollection.getSeriesCount(); i++) {
        KMPlotPointSeries kmSeries = (KMPlotPointSeries) finalDataCollection.getSeries(i);

        if (kmSeries.getType() == KMPlotPointSeries.SeriesType.CENSOR) {
            renderer.setSeriesLinesVisible(i, false);
            renderer.setSeriesShapesVisible(i, true);
            renderer.setSeriesShape(i, getCensorShape());
        } else if (kmSeries.getType() == KMPlotPointSeries.SeriesType.PROBABILITY) {
            renderer.setSeriesLinesVisible(i, true);
            renderer.setSeriesShapesVisible(i, false);

        } else {
            //don't show this set as it is not a known type
            renderer.setSeriesLinesVisible(i, false);
            renderer.setSeriesShapesVisible(i, false);
        }
        renderer.setSeriesPaint(i, getKMSetColor(kmPlotSets, kmSeries.getKey(), kmSeries.getType()), true);
    }

    renderer.setToolTipGenerator(new StandardXYToolTipGenerator());
    renderer.setDefaultEntityRadius(6);
    plot.setRenderer(renderer);

    /* change the auto tick unit selection to integer units only... */
    NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
    rangeAxis.setStandardTickUnits(NumberAxis.createStandardTickUnits());

    /* OPTIONAL CUSTOMISATION COMPLETED. */
    rangeAxis.setAutoRange(true);
    rangeAxis.setRange(0.0, 1.0);

    /* set Title and Legend */
    chart.setTitle(title);
    createLegend(chart, kmPlotSets);

    return chart;
}