Exemple #1
0
  private void jButton2ActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_jButton2ActionPerformed
    double newMinLifetime, newMaxLifetime;
    try {
      newMinLifetime = Double.parseDouble(jTFMinValue.getText());
      newMaxLifetime = Double.parseDouble(jTFMaxValue.getText());

      IntensImageDataset dataValuesDataset =
          new IntensImageDataset(imHeight, imWidth, new double[imWidth * imHeight]);
      for (int i = 0; i < dataValues.length; i++) {
        dataValuesDataset.SetValue(selImInd[i], dataValues[i]);
      }
      PaintScale ps = new RainbowPaintScale(newMinLifetime, newMaxLifetime);
      JFreeChart aveLifetimeChart =
          createScatChart(
              ImageUtilities.createColorCodedImage(dataValuesDataset, ps), ps, imWidth, imHeight);
      aveLifetimeChart.getXYPlot().getRangeAxis().setInverted(true);
      ChartPanel aveLifetimePanel = new ChartPanel(aveLifetimeChart);
      aveLifetimePanel.setFillZoomRectangle(true);
      aveLifetimePanel.setMouseWheelEnabled(true);
      jPImage.removeAll();
      aveLifetimePanel.setSize(jPImage.getSize());
      aveLifetimePanel.addChartMouseListener(listener);
      jPImage.add(aveLifetimePanel);
      jPImage.repaint();
    } catch (NumberFormatException ex) {
      CoreErrorMessages.selCorrChNum();
    }
  } // GEN-LAST:event_jButton2ActionPerformed
 public MouseListenerDemo1(String s) {
   super(s);
   DefaultPieDataset defaultpiedataset = new DefaultPieDataset();
   defaultpiedataset.setValue("Java", new Double(43.200000000000003D));
   defaultpiedataset.setValue("Visual Basic", new Double(0.0D));
   defaultpiedataset.setValue("C/C++", new Double(17.5D));
   org.jfree.chart.JFreeChart jfreechart =
       ChartFactory.createPieChart("Pie Chart Demo 1", defaultpiedataset, true, true, false);
   ChartPanel chartpanel = new ChartPanel(jfreechart, false, false, false, false, false);
   chartpanel.addChartMouseListener(this);
   chartpanel.setPreferredSize(new Dimension(500, 270));
   setContentPane(chartpanel);
 }
  public static JPanel createDemoPanel() {
    JFreeChart jfreechart = createChart();
    ChartPanel chartpanel = new ChartPanel(jfreechart);
    chartpanel.addChartMouseListener(
        new ChartMouseListener() {

          public void chartMouseClicked(ChartMouseEvent chartmouseevent) {
            System.out.println(chartmouseevent.getEntity());
          }

          public void chartMouseMoved(ChartMouseEvent chartmouseevent) {}
        });
    return chartpanel;
  }
  /**
   * Creates a new demo.
   *
   * @param title the frame title.
   */
  public MouseListenerDemo2(String title) {

    super(title);
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();
    dataset.addValue(1.0, "S1", "C1");
    dataset.addValue(4.0, "S1", "C2");
    dataset.addValue(3.0, "S1", "C3");
    dataset.addValue(5.0, "S1", "C4");
    dataset.addValue(5.0, "S1", "C5");
    dataset.addValue(6.0, "S1", "C6");
    dataset.addValue(7.0, "S1", "C7");
    dataset.addValue(8.0, "S1", "C8");
    dataset.addValue(5.0, "S2", "C1");
    dataset.addValue(7.0, "S2", "C2");
    dataset.addValue(6.0, "S2", "C3");
    dataset.addValue(8.0, "S2", "C4");
    dataset.addValue(4.0, "S2", "C5");
    dataset.addValue(4.0, "S2", "C6");
    dataset.addValue(3.0, "S2", "C7");
    dataset.addValue(1.0, "S2", "C8");
    dataset.addValue(4.0, "S3", "C1");
    dataset.addValue(3.0, "S3", "C2");
    dataset.addValue(2.0, "S3", "C3");
    dataset.addValue(3.0, "S3", "C4");
    dataset.addValue(6.0, "S3", "C5");
    dataset.addValue(3.0, "S3", "C6");
    dataset.addValue(4.0, "S3", "C7");
    dataset.addValue(3.0, "S3", "C8");

    JFreeChart chart =
        ChartFactory.createBarChart(
            "MouseListenerDemo2",
            "Category",
            "Value",
            dataset,
            PlotOrientation.VERTICAL,
            true,
            true,
            false);

    // add the chart to a panel...
    ChartPanel chartPanel = new ChartPanel(chart);
    chartPanel.addChartMouseListener(this);
    chartPanel.setPreferredSize(new java.awt.Dimension(500, 270));
    setContentPane(chartPanel);
  }
Exemple #5
0
  public ImageHistPanel(
      String name,
      double[] data,
      int[] selInd,
      int height,
      int width,
      double minVal,
      double maxVal,
      ChartMouseListener listen) {
    initComponents();
    this.dataValues = data;
    this.selImInd = selInd;
    this.imHeight = height;
    this.imWidth = width;
    this.minValue = minVal;
    this.maxValue = maxVal;
    this.jLName.setText(name);
    this.numChHist = 20;
    this.listener = listen;

    jTFChNumHist.setText(String.valueOf(numChHist));
    jTFMaxValue.setText(String.valueOf(maxValue));
    jTFMinValue.setText(String.valueOf(minValue));

    jPHist.add(updateHistPanel(data, minValue, maxValue, numChHist));

    IntensImageDataset dataValuesDataset =
        new IntensImageDataset(imHeight, imWidth, new double[imWidth * imHeight]);
    for (int i = 0; i < dataValues.length; i++) {
      dataValuesDataset.SetValue(selImInd[i], dataValues[i]);
    }
    PaintScale ps = new RainbowPaintScale(0.001, maxValue);
    JFreeChart aveLifetimeChart =
        createScatChart(
            ImageUtilities.createColorCodedImage(dataValuesDataset, ps), ps, imWidth, imHeight);
    ChartPanel aveLifetimePanel = new ChartPanel(aveLifetimeChart);
    aveLifetimePanel.setFillZoomRectangle(true);
    aveLifetimePanel.setMouseWheelEnabled(true);
    aveLifetimePanel.addChartMouseListener(listener);
    jPImage.add(aveLifetimePanel);
  }
    public ChartBoundingPanel(final ChartPanel chartPanel) {
      super(new BorderLayout());
      this.chartPanel = chartPanel;

      add(chartPanel, BorderLayout.CENTER);

      chartPanel.addChartMouseListener(this);

      chartPanel.addMouseListener(
          new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
              if (currEntityIndex != null) {
                currEntities[currEntityIndex] = currEntity;
                currEntityIndex = null;
              } else {
                if (currEntity != null) {
                  for (int i = 0; i < currEntities.length; i++) {
                    System.out.println(i + "  " + currEntities[i].hashCode());
                  }

                  Number val2 =
                      currEntity
                          .getDataset()
                          .getValue(currEntity.getRowKey(), currEntity.getColumnKey());
                  for (int i = 0; i < currEntities.length; i++) {
                    Number val1 =
                        currEntities[i]
                            .getDataset()
                            .getValue(currEntities[i].getRowKey(), currEntities[i].getColumnKey());
                    if (val1.doubleValue() == val2.doubleValue()) {
                      currEntityIndex = i;
                      break;
                    }
                  }
                }
              }
            }
          });
    }
  /**
   * @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());
        });
  }
  /**
   * Returns a sequence plot as a ChartPanel.
   *
   * @param aProteinSequencePanelParent the protein sequence panel parent
   * @param sparklineDataset the dataset
   * @param proteinAnnotations the protein annotations
   * @param addReferenceLine if true, a reference line is added
   * @param allowZooming if true, the user can zoom in the created plot/chart
   * @return a sequence plot
   */
  public ChartPanel getSequencePlot(
      ProteinSequencePanelParent aProteinSequencePanelParent,
      JSparklinesDataset sparklineDataset,
      HashMap<Integer, ArrayList<ResidueAnnotation>> proteinAnnotations,
      boolean addReferenceLine,
      boolean allowZooming) {

    this.proteinSequencePanelParent = aProteinSequencePanelParent;
    DefaultCategoryDataset barChartDataset = new DefaultCategoryDataset();
    StackedBarRenderer renderer = new StackedBarRenderer();
    renderer.setShadowVisible(false);
    CategoryToolTipGenerator myTooltips = new ProteinAnnotations(proteinAnnotations);

    // add the data
    for (int i = 0; i < sparklineDataset.getData().size(); i++) {

      JSparklinesDataSeries sparklineDataSeries = sparklineDataset.getData().get(i);

      for (int j = 0; j < sparklineDataSeries.getData().size(); j++) {
        barChartDataset.addValue(sparklineDataSeries.getData().get(j), "" + i, "" + j);
        renderer.setSeriesPaint(i, sparklineDataSeries.getSeriesColor());
        renderer.setSeriesToolTipGenerator(i, myTooltips);
      }
    }

    // create the chart
    JFreeChart chart =
        ChartFactory.createStackedBarChart(
            null, null, null, barChartDataset, PlotOrientation.HORIZONTAL, false, false, false);

    // fine tune the chart properites
    CategoryPlot plot = chart.getCategoryPlot();

    // remove space before/after the domain axis
    plot.getDomainAxis().setUpperMargin(0);
    plot.getDomainAxis().setLowerMargin(0);

    // remove space before/after the range axis
    plot.getRangeAxis().setUpperMargin(0);
    plot.getRangeAxis().setLowerMargin(0);

    renderer.setRenderAsPercentages(true);
    renderer.setBaseToolTipGenerator(new IntervalCategoryToolTipGenerator());

    // add the dataset to the plot
    plot.setDataset(barChartDataset);

    // hide unwanted chart details
    plot.getRangeAxis().setVisible(false);
    plot.getDomainAxis().setVisible(false);
    plot.setRangeGridlinesVisible(false);
    plot.setDomainGridlinesVisible(false);

    // add a reference line in the middle of the dataset
    if (addReferenceLine) {
      DefaultCategoryDataset referenceLineDataset = new DefaultCategoryDataset();
      referenceLineDataset.addValue(1.0, "A", "B");
      plot.setDataset(1, referenceLineDataset);
      LayeredBarRenderer referenceLineRenderer = new LayeredBarRenderer();
      referenceLineRenderer.setSeriesBarWidth(0, referenceLineWidth);
      referenceLineRenderer.setSeriesFillPaint(0, referenceLineColor);
      referenceLineRenderer.setSeriesPaint(0, referenceLineColor);
      plot.setRenderer(1, referenceLineRenderer);
    }

    // set up the chart renderer
    plot.setRenderer(0, renderer);

    // hide the outline
    chart.getPlot().setOutlineVisible(false);

    // make sure the background is the same as the panel
    chart.getPlot().setBackgroundPaint(backgroundColor);
    chart.setBackgroundPaint(backgroundColor);

    final HashMap<Integer, ArrayList<ResidueAnnotation>> blockTooltips = proteinAnnotations;

    // create the chart panel
    ChartPanel chartPanel = new ChartPanel(chart);

    chartPanel.addChartMouseListener(
        new ChartMouseListener() {

          @Override
          public void chartMouseClicked(ChartMouseEvent cme) {
            if (cme.getEntity() != null && cme.getTrigger().getButton() == MouseEvent.BUTTON1) {

              ((CategoryItemEntity) cme.getEntity()).getDataset();
              Integer blockNumber =
                  new Integer((String) ((CategoryItemEntity) cme.getEntity()).getRowKey());

              ArrayList<ResidueAnnotation> annotation = blockTooltips.get(blockNumber);
              if (annotation != null) {
                proteinSequencePanelParent.annotationClicked(annotation, cme);
              }
            }
          }

          @Override
          public void chartMouseMoved(ChartMouseEvent cme) {

            cme.getTrigger()
                .getComponent()
                .setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));

            if (cme.getEntity() != null && cme.getEntity() instanceof CategoryItemEntity) {
              ((CategoryItemEntity) cme.getEntity()).getDataset();
              Integer blockNumber =
                  new Integer((String) ((CategoryItemEntity) cme.getEntity()).getRowKey());

              ArrayList<ResidueAnnotation> annotation = blockTooltips.get(blockNumber);
              if (annotation != null && !annotation.isEmpty()) {
                if (blockTooltips.get(blockNumber).get(0).isClickable()) {
                  cme.getTrigger()
                      .getComponent()
                      .setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
                }
              }
            }
          }
        });

    if (!allowZooming) {
      chartPanel.setPopupMenu(null);
      chartPanel.setRangeZoomable(false);
    }

    chartPanel.setBackground(Color.WHITE);

    return chartPanel;
  }
  private ChartPanel createChartPanel(JFreeChart chart) {
    profilePlotDisplay = new ChartPanel(chart);

    MaskSelectionToolSupport maskSelectionToolSupport =
        new MaskSelectionToolSupport(
            this,
            profilePlotDisplay,
            "profile_plot_area",
            "Mask generated from selected profile plot area",
            Color.RED,
            PlotAreaSelectionTool.AreaType.Y_RANGE) {

          @Override
          protected String createMaskExpression(
              PlotAreaSelectionTool.AreaType areaType, Shape shape) {
            Rectangle2D bounds = shape.getBounds2D();
            return createMaskExpression(bounds.getMinY(), bounds.getMaxY());
          }

          protected String createMaskExpression(double x1, double x2) {
            String bandName = BandArithmetic.createExternalName(getRaster().getName());
            return String.format("%s >= %s && %s <= %s", bandName, x1, bandName, x2);
          }
        };

    profilePlotDisplay.addChartMouseListener(
        new XYPlotMarker(
            profilePlotDisplay,
            new XYPlotMarker.Listener() {
              @Override
              public void pointSelected(XYDataset xyDataset, int seriesIndex, Point2D dataPoint) {
                if (profileData != null) {
                  GeoPos[] geoPositions = profileData.getGeoPositions();
                  int index = (int) dataPoint.getX();
                  if (index >= 0 && index < geoPositions.length) {
                    if (cursorSynchronizer == null) {
                      cursorSynchronizer = new CursorSynchronizer(VisatApp.getApp());
                    }
                    if (!cursorSynchronizer.isEnabled()) {
                      cursorSynchronizer.setEnabled(true);
                    }
                    cursorSynchronizer.updateCursorOverlays(geoPositions[index]);
                  }
                }
              }

              @Override
              public void pointDeselected() {
                cursorSynchronizer.setEnabled(false);
              }
            }));
    profilePlotDisplay.setInitialDelay(200);
    profilePlotDisplay.setDismissDelay(1500);
    profilePlotDisplay.setReshowDelay(200);
    profilePlotDisplay.setZoomTriggerDistance(5);
    profilePlotDisplay.getPopupMenu().addSeparator();
    profilePlotDisplay
        .getPopupMenu()
        .add(maskSelectionToolSupport.createMaskSelectionModeMenuItem());
    profilePlotDisplay.getPopupMenu().add(maskSelectionToolSupport.createDeleteMaskMenuItem());
    profilePlotDisplay.getPopupMenu().addSeparator();
    profilePlotDisplay.getPopupMenu().add(createCopyDataToClipboardMenuItem());

    return profilePlotDisplay;
  }