Example #1
0
  @SuppressWarnings("deprecation")
  private static JFreeChart createChart(
      int[] dataTitles, String title, String xaxisName, String yaxisName) {
    TimeSeriesCollection timeseriescollection = new TimeSeriesCollection();
    timeSeries = new TimeSeries[dataTitles.length];

    for (int i = 0; i < timeSeries.length; i++) {
      timeSeries[i] = new TimeSeries("No." + dataTitles[i], Millisecond.class);
      timeseriescollection.addSeries(timeSeries[i]);
    }

    JFreeChart jfreechart =
        ChartFactory.createTimeSeriesChart(
            title, xaxisName, yaxisName, timeseriescollection, true, true, false);
    XYPlot xyplot = jfreechart.getXYPlot();
    ValueAxis valueaxis = xyplot.getDomainAxis();
    valueaxis.setAutoRange(true);
    long t = 7200;
    valueaxis.setFixedAutoRange(t * 1000D);

    valueaxis = xyplot.getRangeAxis();
    // valueaxis.setRange(0.0D,200D);

    return jfreechart;
  }
 private void finishScalingUpdate(
     AxisRangeControl axisRangeControl, ValueAxis newAxis, ValueAxis oldAxis) {
   if (axisRangeControl.isAutoMinMax()) {
     newAxis.setAutoRange(false);
     acceptableDeviationDataset.removeAllSeries();
     regressionDataset.removeAllSeries();
     getPlot().removeAnnotation(r2Annotation);
     newAxis.setAutoRange(true);
     axisRangeControl.adjustComponents(newAxis, 3);
     newAxis.setAutoRange(false);
     computeRegressionAndAcceptableDeviationData();
   } else {
     newAxis.setAutoRange(false);
     newAxis.setRange(oldAxis.getRange());
   }
 }
  private void init() {
    timeSeriesList = new LinkedList<TimeSeries>();
    m_average = new TimeSeries(AVERANGE, Millisecond.class);
    m_tps = new TimeSeries(TPS, Millisecond.class);
    m_deviation = new TimeSeries(DEVIATION, Millisecond.class);
    stateMap.put(AVERANGE, m_average);
    stateMap.put(DEVIATION, m_deviation);
    stateMap.put(TPS, m_tps);
    timeSeriesList.add(m_average);
    timeSeriesList.add(m_tps);
    timeSeriesList.add(m_deviation);
    timeseriescollection = new TimeSeriesCollection();
    for (Iterator<TimeSeries> iterator = timeSeriesList.iterator(); iterator.hasNext(); ) {
      timeseriescollection.addSeries(iterator.next());
    }
    jfc =
        ChartFactory.createTimeSeriesChart(
            "Title", "unit", "yaxisName", timeseriescollection, true, true, false);
    // jfc.setTitle(new TextTitle("图表", new Font("黑体", Font.BOLD, 20)));
    // 取得统计图表
    XYPlot xyplot = jfc.getXYPlot();

    xylinerenderer = (XYLineAndShapeRenderer) xyplot.getRenderer();
    xylinerenderer.setSeriesPaint(0, Color.BLUE);
    xylinerenderer.setSeriesPaint(1, Color.GREEN);
    xylinerenderer.setSeriesPaint(2, Color.RED);

    ValueAxis valueaxis = xyplot.getDomainAxis();
    valueaxis.setAutoRange(true);
    valueaxis.setFixedAutoRange(30000D);
    valueaxis = xyplot.getRangeAxis();
    chartPanel = new ChartPanel(jfc);
    chartPanel.setPreferredSize(new Dimension(600, 450));
  }
  /**
   * Constructs a new demonstration application.
   *
   * @param title the frame title.
   */
  public DynamicDataDemo3(String title) {

    super(title);

    CombinedDomainXYPlot plot = new CombinedDomainXYPlot(new DateAxis("Time"));
    this.datasets = new TimeSeriesCollection[SUBPLOT_COUNT];

    for (int i = 0; i < SUBPLOT_COUNT; i++) {
      this.lastValue[i] = 100.0;
      TimeSeries series = new TimeSeries("Random " + i, Millisecond.class);
      this.datasets[i] = new TimeSeriesCollection(series);
      NumberAxis rangeAxis = new NumberAxis("Y" + i);
      rangeAxis.setAutoRangeIncludesZero(false);
      XYPlot subplot = new XYPlot(this.datasets[i], null, rangeAxis, new StandardXYItemRenderer());
      subplot.setBackgroundPaint(Color.lightGray);
      subplot.setDomainGridlinePaint(Color.white);
      subplot.setRangeGridlinePaint(Color.white);
      plot.add(subplot);
    }

    JFreeChart chart = new JFreeChart("Dynamic Data Demo 3", plot);
    chart.getLegend().setAnchor(Legend.EAST);
    chart.setBorderPaint(Color.black);
    chart.setBorderVisible(true);
    chart.setBackgroundPaint(Color.white);

    plot.setBackgroundPaint(Color.lightGray);
    plot.setDomainGridlinePaint(Color.white);
    plot.setRangeGridlinePaint(Color.white);
    plot.setAxisOffset(new Spacer(Spacer.ABSOLUTE, 4, 4, 4, 4));
    ValueAxis axis = plot.getDomainAxis();
    axis.setAutoRange(true);
    axis.setFixedAutoRange(60000.0); // 60 seconds

    JPanel content = new JPanel(new BorderLayout());

    ChartPanel chartPanel = new ChartPanel(chart);
    content.add(chartPanel);

    JPanel buttonPanel = new JPanel(new FlowLayout());

    for (int i = 0; i < SUBPLOT_COUNT; i++) {
      JButton button = new JButton("Series " + i);
      button.setActionCommand("ADD_DATA_" + i);
      button.addActionListener(this);
      buttonPanel.add(button);
    }
    JButton buttonAll = new JButton("ALL");
    buttonAll.setActionCommand("ADD_ALL");
    buttonAll.addActionListener(this);
    buttonPanel.add(buttonAll);

    content.add(buttonPanel, BorderLayout.SOUTH);
    chartPanel.setPreferredSize(new java.awt.Dimension(500, 470));
    chartPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    setContentPane(content);
  }
 /**
  * Sets the properties of the specified axis to match the properties defined on this panel.
  *
  * @param axis the axis.
  */
 public void setAxisProperties(Axis axis) {
   super.setAxisProperties(axis);
   ValueAxis valueAxis = (ValueAxis) axis;
   valueAxis.setAutoRange(this.autoRange);
   if (!this.autoRange) {
     valueAxis.setRange(this.minimumValue, this.maximumValue);
   }
   valueAxis.setAutoTickUnitSelection(this.autoTickUnitSelection);
 }
Example #6
0
 private JFreeChart createChart(XYDataset xydataset) {
   JFreeChart jfreechart =
       ChartFactory.createTimeSeriesChart(
           "Serialization Test 1", "Time", "Value", xydataset, true, true, false);
   XYPlot xyplot = (XYPlot) jfreechart.getPlot();
   ValueAxis valueaxis = xyplot.getDomainAxis();
   valueaxis.setAutoRange(true);
   valueaxis.setFixedAutoRange(60000D);
   return jfreechart;
 }
    /** Creates a new self-contained demo panel. */
    public MyDemoPanel() {
      super(new BorderLayout());
      this.series1 = new TimeSeries("Random 1");
      this.series2 = new TimeSeries("Random 2");
      TimeSeriesCollection dataset1 = new TimeSeriesCollection(this.series1);
      TimeSeriesCollection dataset2 = new TimeSeriesCollection(this.series2);
      JFreeChart chart =
          ChartFactory.createTimeSeriesChart(
              "Dynamic Data Demo 2", "Time", "Value", dataset1, true, true, false);
      // addChart(chart);

      XYPlot plot = (XYPlot) chart.getPlot();
      ValueAxis axis = plot.getDomainAxis();
      axis.setAutoRange(true);
      axis.setFixedAutoRange(10000.0); // 10 seconds

      plot.setDataset(1, dataset2);
      NumberAxis rangeAxis2 = new NumberAxis("Range Axis 2");
      rangeAxis2.setAutoRangeIncludesZero(false);
      plot.setRenderer(1, new DefaultXYItemRenderer());
      plot.setRangeAxis(1, rangeAxis2);
      plot.mapDatasetToRangeAxis(1, 1);

      ChartUtilities.applyCurrentTheme(chart);

      ChartPanel chartPanel = new ChartPanel(chart);
      // add(chartPanel);

      JButton button1 = new JButton("Add To Series 1");
      button1.setActionCommand("ADD_DATA_1");
      button1.addActionListener(this);

      JButton button2 = new JButton("Add To Series 2");
      button2.setActionCommand("ADD_DATA_2");
      button2.addActionListener(this);

      JButton button3 = new JButton("Add To Both");
      button3.setActionCommand("ADD_BOTH");
      button3.addActionListener(this);

      JPanel buttonPanel = new JPanel(new FlowLayout());
      buttonPanel.setBackground(Color.white);
      buttonPanel.add(button1);
      buttonPanel.add(button2);
      buttonPanel.add(button3);

      // add(buttonPanel, BorderLayout.SOUTH);
      chartPanel.setPreferredSize(new java.awt.Dimension(500, 270));
    }
Example #8
0
    public MyDemoPanel() {
      super(new BorderLayout());
      lastValue = new double[3];
      CombinedDomainXYPlot combineddomainxyplot = new CombinedDomainXYPlot(new DateAxis("Time"));
      datasets = new TimeSeriesCollection[3];
      for (int i = 0; i < 3; i++) {
        lastValue[i] = 100D;
        TimeSeries timeseries = new TimeSeries("Random " + i);
        datasets[i] = new TimeSeriesCollection(timeseries);
        NumberAxis numberaxis = new NumberAxis("Y" + i);
        numberaxis.setAutoRangeIncludesZero(false);
        XYPlot xyplot = new XYPlot(datasets[i], null, numberaxis, new StandardXYItemRenderer());
        xyplot.setBackgroundPaint(Color.lightGray);
        xyplot.setDomainGridlinePaint(Color.white);
        xyplot.setRangeGridlinePaint(Color.white);
        combineddomainxyplot.add(xyplot);
      }

      JFreeChart jfreechart = new JFreeChart("Dynamic Data Demo 3", combineddomainxyplot);
      addChart(jfreechart);
      LegendTitle legendtitle = (LegendTitle) jfreechart.getSubtitle(0);
      legendtitle.setPosition(RectangleEdge.RIGHT);
      legendtitle.setMargin(new RectangleInsets(UnitType.ABSOLUTE, 0.0D, 4D, 0.0D, 4D));
      jfreechart.setBorderPaint(Color.black);
      jfreechart.setBorderVisible(true);
      ValueAxis valueaxis = combineddomainxyplot.getDomainAxis();
      valueaxis.setAutoRange(true);
      valueaxis.setFixedAutoRange(20000D);
      ChartUtilities.applyCurrentTheme(jfreechart);
      ChartPanel chartpanel = new ChartPanel(jfreechart);
      add(chartpanel);
      JPanel jpanel = new JPanel(new FlowLayout());
      for (int j = 0; j < 3; j++) {
        JButton jbutton1 = new JButton("Series " + j);
        jbutton1.setActionCommand("ADD_DATA_" + j);
        jbutton1.addActionListener(this);
        jpanel.add(jbutton1);
      }

      JButton jbutton = new JButton("ALL");
      jbutton.setActionCommand("ADD_ALL");
      jbutton.addActionListener(this);
      jpanel.add(jbutton);
      add(jpanel, "South");
      chartpanel.setPreferredSize(new Dimension(500, 470));
      chartpanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
    }
Example #9
0
  private static JFreeChart createChart(String chartContent, String title, String yaxisName) {
    // 创建时序图对象
    timeSeries = new TimeSeries(chartContent, Millisecond.class);
    TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(timeSeries);
    jfreechart =
        ChartFactory.createTimeSeriesChart(
            title, "time(s)", yaxisName, timeseriescollection, true, true, false);
    XYPlot xyplot = jfreechart.getXYPlot();
    // 纵坐标设定
    ValueAxis valueaxis = xyplot.getDomainAxis();
    // 自动设置数据轴数据范围
    valueaxis.setAutoRange(true);
    // 数据轴固定数据范围 30s
    valueaxis.setFixedAutoRange(30000D);

    valueaxis = xyplot.getRangeAxis();
    // valueaxis.setRange(0.0D,200D);

    return jfreechart;
  }
  /**
   * @param name Chart name
   * @param parent Skeleton parent
   * @param axes Configuration of axes
   * @param abcissaName Abcissa name
   */
  public SwingChart(String name, final Skeleton parent, List<AxisChart> axes, String abcissaName) {
    this.skeleton = parent;
    this.axes = axes;
    this.name = name;

    this.abcissaFormat = NumberFormat.getInstance(Locale.getDefault());
    this.ordinateFormat = NumberFormat.getInstance(Locale.getDefault());

    plot = new XYPlot();
    plot.setBackgroundPaint(scene2awtColor(javafx.scene.paint.Color.web(strChartBackgroundColor)));
    plot.setDomainGridlinePaint(scene2awtColor(javafx.scene.paint.Color.web(strGridlineColor)));
    plot.setRangeGridlinePaint(scene2awtColor(javafx.scene.paint.Color.web(strGridlineColor)));
    plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 5.0));

    abcissaAxis = new NumberAxis(abcissaName);
    ((NumberAxis) abcissaAxis).setAutoRangeIncludesZero(false);
    abcissaAxis.setTickLabelFont(new Font("SansSerif", Font.PLAIN, 12));
    abcissaAxis.setLabelFont(new Font("SansSerif", Font.PLAIN, 12));
    abcissaAxis.setLabelPaint(scene2awtColor(javafx.scene.paint.Color.web(strTickColor)));
    abcissaAxis.setTickLabelPaint(scene2awtColor(javafx.scene.paint.Color.web(strTickColor)));
    abcissaAxis.setAutoRange(true);
    abcissaAxis.setLowerMargin(0.0);
    abcissaAxis.setUpperMargin(0.0);
    abcissaAxis.setTickLabelsVisible(true);
    abcissaAxis.setLabelFont(abcissaAxis.getLabelFont().deriveFont(fontSize));
    abcissaAxis.setTickLabelFont(abcissaAxis.getLabelFont().deriveFont(fontSize));

    plot.setDomainAxis(abcissaAxis);

    for (int i = 0; i < axes.size(); i++) {
      AxisChart categoria = axes.get(i);
      addAxis(categoria.getName());

      for (int j = 0; j < categoria.configSerieList.size(); j++) {
        SimpleSeriesConfiguration cs = categoria.configSerieList.get(j);
        addSeries(categoria.getName(), cs);
      }
    }
    chart = new JFreeChart("", new Font("SansSerif", Font.BOLD, 16), plot, false);

    chart.setBackgroundPaint(scene2awtColor(javafx.scene.paint.Color.web(strBackgroundColor)));

    chartPanel = new ChartPanel(chart);
    chartPanel.setBorder(
        BorderFactory.createCompoundBorder(
            BorderFactory.createEmptyBorder(4, 4, 4, 4),
            BorderFactory.createLineBorder(
                scene2awtColor(javafx.scene.paint.Color.web(strBackgroundColor)))));

    chartPanel.getInputMap().put(KeyStroke.getKeyStroke("ESCAPE"), "escape");
    chartPanel
        .getActionMap()
        .put(
            "escape",
            new AbstractAction() {

              @Override
              public void actionPerformed(java.awt.event.ActionEvent e) {
                for (int i = 0; i < plot.getDatasetCount(); i++) {
                  XYDataset test = plot.getDataset(i);
                  XYItemRenderer r = plot.getRenderer(i);
                  r.removeAnnotations();
                }
              }
            });

    chartPanel.addChartMouseListener(
        cml =
            new ChartMouseListener() {
              @Override
              public void chartMouseClicked(ChartMouseEvent event) {}

              @Override
              public void chartMouseMoved(ChartMouseEvent event) {
                try {
                  XYItemEntity xyitem = (XYItemEntity) event.getEntity(); // get clicked entity
                  XYDataset dataset = (XYDataset) xyitem.getDataset(); // get data set
                  double x = dataset.getXValue(xyitem.getSeriesIndex(), xyitem.getItem());
                  double y = dataset.getYValue(xyitem.getSeriesIndex(), xyitem.getItem());

                  final XYPlot plot = chart.getXYPlot();
                  for (int i = 0; i < plot.getDatasetCount(); i++) {
                    XYDataset test = plot.getDataset(i);
                    XYItemRenderer r = plot.getRenderer(i);
                    r.removeAnnotations();
                    if (test == dataset) {
                      NumberAxis ejeOrdenada = AxesList.get(i);
                      double y_max = ejeOrdenada.getUpperBound();
                      double y_min = ejeOrdenada.getLowerBound();
                      double x_max = abcissaAxis.getUpperBound();
                      double x_min = abcissaAxis.getLowerBound();
                      double angulo;
                      if (y > (y_max + y_min) / 2 && x > (x_max + x_min) / 2) {
                        angulo = 3.0 * Math.PI / 4.0;
                      } else if (y > (y_max + y_min) / 2 && x < (x_max + x_min) / 2) {
                        angulo = 1.0 * Math.PI / 4.0;
                      } else if (y < (y_max + y_min) / 2 && x < (x_max + x_min) / 2) {
                        angulo = 7.0 * Math.PI / 4.0;
                      } else {
                        angulo = 5.0 * Math.PI / 4.0;
                      }

                      CircleDrawer cd =
                          new CircleDrawer(
                              (Color) r.getSeriesPaint(xyitem.getSeriesIndex()),
                              new BasicStroke(2.0f),
                              null);
                      // XYAnnotation bestBid = new
                      // XYDrawableAnnotation(dataset.getXValue(xyitem.getSeriesIndex(),
                      // xyitem.getItem()), dataset.getYValue(xyitem.getSeriesIndex(),
                      // xyitem.getItem()), 11, 11, cd);
                      String txt =
                          "X:" + abcissaFormat.format(x) + ", Y:" + ordinateFormat.format(y);
                      XYPointerAnnotation anotacion =
                          new XYPointerAnnotation(
                              txt,
                              dataset.getXValue(xyitem.getSeriesIndex(), xyitem.getItem()),
                              dataset.getYValue(xyitem.getSeriesIndex(), xyitem.getItem()),
                              angulo);
                      anotacion.setTipRadius(10.0);
                      anotacion.setBaseRadius(35.0);
                      anotacion.setFont(new Font("SansSerif", Font.PLAIN, 10));

                      if (Long.parseLong((strChartBackgroundColor.replace("#", "")), 16)
                          > 0xffffff / 2) {
                        anotacion.setPaint(Color.black);
                        anotacion.setArrowPaint(Color.black);
                      } else {
                        anotacion.setPaint(Color.white);
                        anotacion.setArrowPaint(Color.white);
                      }

                      // bestBid.setPaint((Color) r.getSeriesPaint(xyitem.getSeriesIndex()));
                      r.addAnnotation(anotacion);
                    }
                  }

                  // LabelValorVariable.setSize(LabelValorVariable.getPreferredSize());
                } catch (NullPointerException | ClassCastException ex) {

                }
              }
            });

    chartPanel.setPopupMenu(null);
    chartPanel.setBackground(scene2awtColor(javafx.scene.paint.Color.web(strBackgroundColor)));

    SwingNode sn = new SwingNode();
    sn.setContent(chartPanel);
    chartFrame = new VBox();
    chartFrame.getChildren().addAll(sn, legendFrame);
    VBox.setVgrow(sn, Priority.ALWAYS);
    VBox.setVgrow(legendFrame, Priority.NEVER);

    chartFrame
        .getStylesheets()
        .addAll(SwingChart.class.getResource("overlay-chart.css").toExternalForm());

    legendFrame.setStyle("marco: " + strBackgroundColor + ";-fx-background-color: marco;");

    MenuItem mi;
    mi = new MenuItem("Print");
    mi.setOnAction(
        (ActionEvent t) -> {
          print(chartFrame);
        });
    contextMenuList.add(mi);

    sn.setOnMouseClicked(
        (MouseEvent t) -> {
          if (menu != null) {
            menu.hide();
          }
          if (t.getClickCount() == 2) {
            backgroundEdition();
          }
        });

    mi = new MenuItem("Copy to clipboard");
    mi.setOnAction(
        (ActionEvent t) -> {
          copyClipboard(chartFrame);
        });
    contextMenuList.add(mi);

    mi = new MenuItem("Export values");
    mi.setOnAction(
        (ActionEvent t) -> {
          FileChooser fileChooser = new FileChooser();
          fileChooser.setTitle("Export to file");
          fileChooser
              .getExtensionFilters()
              .addAll(new FileChooser.ExtensionFilter("Comma Separated Values", "*.csv"));

          Window w = null;
          try {
            w = parent.getScene().getWindow();
          } catch (NullPointerException e) {

          }
          File file = fileChooser.showSaveDialog(w);
          if (file != null) {
            export(file);
          }
        });
    contextMenuList.add(mi);

    chartFrame.setOnContextMenuRequested(
        (ContextMenuEvent t) -> {
          if (menu != null) {
            menu.hide();
          }
          menu = new ContextMenu();
          menu.getItems().addAll(contextMenuList);
          menu.show(chartFrame, t.getScreenX(), t.getScreenY());
        });
  }
 /**
  * Set abcissa upper and lower limits
  *
  * @param lower Lower limit
  * @param upper Upper limit
  */
 @Override
 public void setAbcissaRange(double lower, double upper) {
   abcissaAxis.setAutoRange(false);
   abcissaAxis.setUpperBound(upper);
   abcissaAxis.setLowerBound(lower);
 }
  public String generateXYChart(
      String section, HttpSession session, PrintWriter pw, String courseId, int studentId) {
    /*int groupId=0;
                if (groupName.equals("All")){
                    groupId=0;
                }else{
                     groupId = studStatisticBean.getGroupIdByName(groupName);
    }*/
    String filename = null;
    try {
      //  Retrieve list of WebHits
      StudentsConceptChartDataSet cDataSet =
          new StudentsConceptChartDataSet(studStatisticBean, courseId, studentId);
      ArrayList list = cDataSet.getDataByHitConcept(section);
      //  Throw a custom NoDataException if there is no data
      if (list.size() == 0) {
        System.out.println("No data has been found");
        throw new NoDataException();
      }
      //  Create and populate an XYSeries Collection
      XYSeries dataSeries = new XYSeries("Students progress line");
      Iterator iter = list.listIterator();
      while (iter.hasNext()) {
        StudentsConceptHit ch = (StudentsConceptHit) iter.next();
        dataSeries.add(ch.getOrdNumb(), ch.getHitDegree());
      }
      XYSeriesCollection xyDataset = new XYSeriesCollection(dataSeries);

      NumberFormat nf = NumberFormat.getIntegerInstance();
      NumberFormat nf2 = NumberFormat.getInstance();

      String cTitle = null;
      // StandardXYToolTipGenerator ttg = new
      // StandardXYToolTipGenerator(StandardXYToolTipGenerator.DEFAULT_TOOL_TIP_FORMAT,nf,nf2);
      CustomXYToolTipGenerator ttg = new CustomXYToolTipGenerator();
      ttg.addToolTipSeries(cDataSet.getConceptNames());
      StandardXYURLGenerator sxyUrlGen =
          new StandardXYURLGenerator("#", xyDataset.getSeriesName(0), "PassedConceptOrdNum");

      ValueAxis ordNumAxis = new NumberAxis("Concept ordinal number");
      NumberAxis valueAxis = new NumberAxis("Current knowledge");
      // valueAxis.setAutoRangeIncludesZero(true);
      valueAxis.setRange(0.0, 6.0); // override default
      ordNumAxis.setAutoRange(true);
      ordNumAxis.setLowerMargin(0.0);

      StandardXYItemRenderer renderer =
          new StandardXYItemRenderer(
              StandardXYItemRenderer.LINES + StandardXYItemRenderer.SHAPES, ttg, sxyUrlGen);
      Marker marker = new ValueMarker(1.50); // /
      Marker marker2 = new ValueMarker(2.50);
      Marker marker3 = new ValueMarker(3.50);
      Marker marker4 = new ValueMarker(4.50);
      Marker marker5 = new ValueMarker(5.00);

      renderer.setShapesFilled(true);
      XYPlot plot = new XYPlot(xyDataset, ordNumAxis, valueAxis, renderer);

      plot.addRangeMarker(marker);
      plot.addRangeMarker(marker2);
      plot.addRangeMarker(marker3);
      plot.addRangeMarker(marker4);
      plot.addRangeMarker(marker5);

      XYTextAnnotation xyBad = new XYTextAnnotation("Bad", 1, 1);
      xyBad.setX(0.2);
      xyBad.setY(0.75);
      XYTextAnnotation xyNotBad = new XYTextAnnotation("Not Bad", 1, 1);
      xyNotBad.setX(0.2);
      xyNotBad.setY(2);
      XYTextAnnotation xyGood = new XYTextAnnotation("Good", 1, 1);
      xyGood.setX(0.2);
      xyGood.setY(3);
      XYTextAnnotation xyVeryGood = new XYTextAnnotation("Very Good", 1, 1);
      xyVeryGood.setX(0.2);
      xyVeryGood.setY(4);
      XYTextAnnotation xyExcellent = new XYTextAnnotation("Excellent", 1, 1);
      xyExcellent.setX(0.2);
      xyExcellent.setY(4.75);

      XYTextAnnotation xyExpert = new XYTextAnnotation("Expert", 1, 1);
      xyExpert.setX(0.2);
      xyExpert.setY(5.25);

      plot.addAnnotation(xyBad);
      plot.addAnnotation(xyNotBad);
      plot.addAnnotation(xyGood);
      plot.addAnnotation(xyVeryGood);
      plot.addAnnotation(xyExcellent);
      plot.addAnnotation(xyExpert);

      JFreeChart chart = new JFreeChart("", JFreeChart.DEFAULT_TITLE_FONT, plot, true);
      chart.setBackgroundPaint(java.awt.Color.white);

      //  Write the chart image to the temporary directory
      ChartRenderingInfo info = new ChartRenderingInfo(new StandardEntityCollection());
      filename = ServletUtilities.saveChartAsPNG(chart, 600, 400, info, session);

      //  Write the image map to the PrintWriter
      ChartUtilities.writeImageMap(pw, filename, info);
      pw.flush();

    } catch (NoDataException e) {
      System.out.println(e.toString());
      filename = "public_nodata_500x300.png";
    } catch (Exception e) {
      System.out.println("Exception - " + e.toString());
      e.printStackTrace(System.out);
      filename = "public_error_500x300.png";
    }

    return filename;
  }
Example #13
0
  @Override
  protected void initComponents() {
    getAlternativeView().initComponents();
    dataset = new XYIntervalSeriesCollection();
    this.chart =
        ChartFactory.createXYLineChart(
            CHART_TITLE,
            "Path in pixels",
            DEFAULT_SAMPLE_DATASET_NAME,
            dataset,
            PlotOrientation.VERTICAL,
            true,
            true,
            false);
    final XYPlot plot = chart.getXYPlot();

    deviationRenderer = new DeviationRenderer();
    deviationRenderer.setUseFillPaint(true);
    deviationRenderer.setBaseToolTipGenerator(new XYPlotToolTipGenerator());
    deviationRenderer.setSeriesLinesVisible(0, true);
    deviationRenderer.setSeriesShapesVisible(0, false);
    deviationRenderer.setSeriesStroke(0, new BasicStroke(1.0f));
    deviationRenderer.setSeriesPaint(0, StatisticChartStyling.SAMPLE_DATA_PAINT);
    deviationRenderer.setSeriesFillPaint(0, StatisticChartStyling.SAMPLE_DATA_FILL_PAINT);

    pointRenderer = new XYErrorRenderer();
    pointRenderer.setUseFillPaint(true);
    pointRenderer.setBaseToolTipGenerator(new XYPlotToolTipGenerator());
    pointRenderer.setSeriesLinesVisible(0, false);
    pointRenderer.setSeriesShapesVisible(0, true);
    pointRenderer.setSeriesStroke(0, new BasicStroke(1.0f));
    pointRenderer.setSeriesPaint(0, StatisticChartStyling.SAMPLE_DATA_PAINT);
    pointRenderer.setSeriesFillPaint(0, StatisticChartStyling.SAMPLE_DATA_FILL_PAINT);
    pointRenderer.setSeriesShape(0, StatisticChartStyling.SAMPLE_DATA_POINT_SHAPE);

    configureRendererForCorrelativeData(deviationRenderer);
    configureRendererForCorrelativeData(pointRenderer);

    plot.setNoDataMessage(NO_DATA_MESSAGE);
    plot.setAxisOffset(new RectangleInsets(5, 5, 5, 5));
    plot.setRenderer(deviationRenderer);

    final AxisChangeListener axisListener =
        new AxisChangeListener() {
          @Override
          public void axisChanged(AxisChangeEvent event) {
            adjustAxisControlComponents();
          }
        };

    final ValueAxis domainAxis = plot.getDomainAxis();
    final ValueAxis rangeAxis = plot.getRangeAxis();
    // allow transfer from bounds into min/max fields, if auto min/maxis enabled
    domainAxis.setAutoRange(true);
    rangeAxis.setAutoRange(true);

    domainAxis.addChangeListener(axisListener);
    rangeAxis.addChangeListener(axisListener);

    intervalMarkers = new HashSet<IntervalMarker>();

    xAxisRangeControl = new AxisRangeControl("X-Axis");
    yAxisRangeControl = new AxisRangeControl("Y-Axis");

    final PropertyChangeListener changeListener =
        new PropertyChangeListener() {
          @Override
          public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getPropertyName().equals(PROPERTY_NAME_MARK_SEGMENTS)) {
              updateDataSet();
            }
            if (evt.getPropertyName().equals(PROPERTY_NAME_LOG_SCALED)) {
              updateScalingOfYAxis();
            }
            updateUIState();
          }
        };
    xAxisRangeControl.getBindingContext().addPropertyChangeListener(changeListener);
    xAxisRangeControl
        .getBindingContext()
        .getPropertySet()
        .addProperty(Property.create(PROPERTY_NAME_MARK_SEGMENTS, false));
    xAxisRangeControl
        .getBindingContext()
        .getPropertySet()
        .getDescriptor(PROPERTY_NAME_MARK_SEGMENTS)
        .setDescription("Toggle whether to mark segments");

    yAxisRangeControl.getBindingContext().addPropertyChangeListener(changeListener);
    yAxisRangeControl
        .getBindingContext()
        .getPropertySet()
        .addProperty(Property.create(PROPERTY_NAME_LOG_SCALED, false));
    yAxisRangeControl
        .getBindingContext()
        .getPropertySet()
        .getDescriptor(PROPERTY_NAME_LOG_SCALED)
        .setDescription("Toggle whether to use a logarithmic axis");

    dataSourceConfig = new DataSourceConfig();
    final BindingContext bindingContext =
        new BindingContext(PropertyContainer.createObjectBacked(dataSourceConfig));

    JPanel middlePanel = createMiddlePanel(bindingContext);
    createUI(createChartPanel(chart), middlePanel, bindingContext);

    isInitialized = true;

    updateComponents();
  }
  private JFreeChart createChart() {

    // create the chart...
    JFreeChart chart =
        ChartFactory.createXYLineChart(
            null, // chart title
            null, // x axis label
            null, // y axis label
            null, // data
            PlotOrientation.VERTICAL,
            false, // include legend
            true, // tooltips
            false // urls
            );

    chart.setBackgroundPaint(Color.white);

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

    // domain axis

    if ((indexAxis >= 0) && (!dataTable.isNominal(indexAxis))) {
      if ((dataTable.isDate(indexAxis)) || (dataTable.isDateTime(indexAxis))) {
        DateAxis domainAxis = new DateAxis(dataTable.getColumnName(indexAxis));
        domainAxis.setTimeZone(Tools.getPreferredTimeZone());
        chart.getXYPlot().setDomainAxis(domainAxis);
      }
    } else {
      plot.getDomainAxis().setStandardTickUnits(NumberAxis.createIntegerTickUnits(Locale.US));
      ((NumberAxis) plot.getDomainAxis()).setAutoRangeStickyZero(false);
      ((NumberAxis) plot.getDomainAxis()).setAutoRangeIncludesZero(false);
    }
    ValueAxis xAxis = plot.getDomainAxis();
    if (indexAxis > -1) xAxis.setLabel(getDataTable().getColumnName(indexAxis));
    else xAxis.setLabel(SERIESINDEX_LABEL);
    xAxis.setAutoRange(true);
    xAxis.setLabelFont(LABEL_FONT_BOLD);
    xAxis.setTickLabelFont(LABEL_FONT);
    xAxis.setVerticalTickLabels(isLabelRotating());
    if (indexAxis > 0) {
      if (getRangeForDimension(indexAxis) != null) {
        xAxis.setRange(getRangeForDimension(indexAxis));
      }
    } else {
      if (getRangeForName(SERIESINDEX_LABEL) != null) {
        xAxis.setRange(getRangeForName(SERIESINDEX_LABEL));
      }
    }

    // renderer and range axis
    synchronized (dataTable) {
      int numberOfSelectedColumns = 0;
      for (int c = 0; c < dataTable.getNumberOfColumns(); c++) {
        if (getPlotColumn(c)) {
          if (dataTable.isNumerical(c)) {
            numberOfSelectedColumns++;
          }
        }
      }

      int columnCount = 0;
      for (int c = 0; c < dataTable.getNumberOfColumns(); c++) {
        if (getPlotColumn(c)) {
          if (dataTable.isNumerical(c)) {
            // YIntervalSeries series = new YIntervalSeries(this.dataTable.getColumnName(c));
            XYSeriesCollection dataset = new XYSeriesCollection();
            XYSeries series = new XYSeries(dataTable.getColumnName(c));
            Iterator<DataTableRow> i = dataTable.iterator();
            int index = 1;
            while (i.hasNext()) {
              DataTableRow row = i.next();
              double value = row.getValue(c);

              if ((indexAxis >= 0) && (!dataTable.isNominal(indexAxis))) {
                double indexValue = row.getValue(indexAxis);
                series.add(indexValue, value);
              } else {
                series.add(index++, value);
              }
            }
            dataset.addSeries(series);

            XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();

            Color color = getColorProvider().getPointColor(1.0d);
            if (numberOfSelectedColumns > 1) {
              color =
                  getColorProvider()
                      .getPointColor(columnCount / (double) (numberOfSelectedColumns - 1));
            }
            renderer.setSeriesPaint(0, color);
            renderer.setSeriesStroke(
                0, new BasicStroke(1.5f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
            renderer.setSeriesShapesVisible(0, false);

            NumberAxis yAxis = new NumberAxis(dataTable.getColumnName(c));
            if (getRangeForDimension(c) != null) {
              yAxis.setRange(getRangeForDimension(c));
            } else {
              yAxis.setAutoRange(true);
              yAxis.setAutoRangeStickyZero(false);
              yAxis.setAutoRangeIncludesZero(false);
            }
            yAxis.setLabelFont(LABEL_FONT_BOLD);
            yAxis.setTickLabelFont(LABEL_FONT);
            if (numberOfSelectedColumns > 1) {
              yAxis.setAxisLinePaint(color);
              yAxis.setTickMarkPaint(color);
              yAxis.setLabelPaint(color);
              yAxis.setTickLabelPaint(color);
            }

            plot.setRangeAxis(columnCount, yAxis);
            plot.setRangeAxisLocation(columnCount, AxisLocation.TOP_OR_LEFT);

            plot.setDataset(columnCount, dataset);
            plot.setRenderer(columnCount, renderer);
            plot.mapDatasetToRangeAxis(columnCount, columnCount);

            columnCount++;
          }
        }
      }
    }

    chart.setBackgroundPaint(Color.white);

    return chart;
  }