Develop Reference

how to add text to jfree polar plot?

Starting from the java code below , is there a way to add text on jfree plot ?
The aim is to obtain a plot like posted with "aa" "bb "cc" .
"filling text ................."
Thank you
tinitus
package jfreechart;
import javax.swing.JFrame;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
public class JFreeChartPolarChartExample2 extends JFrame {
private static final long serialVersionUID = 1L;
public JFreeChartPolarChartExample2(String applicationTitle) {
super(applicationTitle);
XYSeriesCollection dataSet1 = new XYSeriesCollection();
JFreeChart jfreeChart = ChartFactory.createPolarChart(null, dataSet1, true, true, false);
final XYSeries series = new XYSeries(" serie1");
series.add(10, 0.90);
series.add(100, 0.10);
series.add(195, 0.50);
series.add(295, 0.50);
dataSet1.addSeries(series);
PolarPlot polarPlot = (PolarPlot) jfreeChart.getPlot();
ChartPanel chartPanel = new ChartPanel(jfreeChart);
chartPanel.setPreferredSize(new java.awt.Dimension(500, 500));
setContentPane(chartPanel);
}
public static void main(String[] args) {
JFreeChartPolarChartExample2 chart = new JFreeChartPolarChartExample2(null);
chart.pack();
chart.setVisible(true);
}
}

how to add circular graduations otherwise circles to polar plot?

Starting from the code below , is there a way to add graduation to plot ?
the aim is to obtain a plot like posted.
i found addannotation for linechart plot but not for polar ...
Thank you
package jfreechart;
import javax.swing.JFrame;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
public class JFreeChartPolarChartExample2 extends JFrame {
private static final long serialVersionUID = 1L;
public JFreeChartPolarChartExample2(String applicationTitle) {
super(applicationTitle);
XYSeriesCollection dataSet1 = new XYSeriesCollection();
JFreeChart jfreeChart = ChartFactory.createPolarChart(null, dataSet1, true, true, false);
final XYSeries series = new XYSeries(" serie1");
series.add(10, 0.90);
series.add(100, 0.10);
series.add(195, 0.50);
series.add(295, 0.50);
dataSet1.addSeries(series);
PolarPlot polarPlot = (PolarPlot) jfreeChart.getPlot();
ChartPanel chartPanel = new ChartPanel(jfreeChart);
chartPanel.setPreferredSize(new java.awt.Dimension(500, 500));
setContentPane(chartPanel);
}
public static void main(String[] args) {
JFreeChartPolarChartExample2 chart = new JFreeChartPolarChartExample2(null);
chart.pack();
chart.setVisible(true);
}
}

How can I read all values on crossline in JFreeChart? [duplicate]

On an XYPlot, I want the coordinates of mouse displayed as hint near to mouse, but only when (the mouse) move on chart! In another words, when the crosshair moves to another point, the positioning of the coordinate values would move too, following the crosshair.
Also 1 horizontal line and 1 vertical line will be drawn, that intersects specifically at the point that mouse is over on.
Is this possible?
Until now I can get the coordinates and printed on console using ChartMouseListener and chartMouseMoved method.
This is my project and how I want to be the chart with mouse.

JFreeChart has quite flexible support for crosshairs. To do what you described I would use an Overlay on the ChartPanel, and update the crosshairs from your ChartMouseListener. Here is a self-contained example (which I'll add to the collection of demos that we ship with the JFreeChart Developer Guide):
package org.jfree.chart.demo;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.geom.Rectangle2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartMouseEvent;
import org.jfree.chart.ChartMouseListener;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.panel.CrosshairOverlay;
import org.jfree.chart.plot.Crosshair;
import org.jfree.chart.plot.XYPlot;
import org.jfree.data.general.DatasetUtilities;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.ui.RectangleEdge;
/**
* A demo showing crosshairs that follow the data points on an XYPlot.
*/
public class CrosshairOverlayDemo1 extends JFrame implements ChartMouseListener {
private ChartPanel chartPanel;
private Crosshair xCrosshair;
private Crosshair yCrosshair;
public CrosshairOverlayDemo1(String title) {
super(title);
setContentPane(createContent());
}
private JPanel createContent() {
JFreeChart chart = createChart(createDataset());
this.chartPanel = new ChartPanel(chart);
this.chartPanel.addChartMouseListener(this);
CrosshairOverlay crosshairOverlay = new CrosshairOverlay();
this.xCrosshair = new Crosshair(Double.NaN, Color.GRAY, new BasicStroke(0f));
this.xCrosshair.setLabelVisible(true);
this.yCrosshair = new Crosshair(Double.NaN, Color.GRAY, new BasicStroke(0f));
this.yCrosshair.setLabelVisible(true);
crosshairOverlay.addDomainCrosshair(xCrosshair);
crosshairOverlay.addRangeCrosshair(yCrosshair);
chartPanel.addOverlay(crosshairOverlay);
return chartPanel;
}
private JFreeChart createChart(XYDataset dataset) {
JFreeChart chart = ChartFactory.createXYLineChart("Crosshair Demo",
"X", "Y", dataset);
return chart;
}
private XYDataset createDataset() {
XYSeries series = new XYSeries("S1");
for (int x = 0; x < 10; x++) {
series.add(x, x + Math.random() * 4.0);
}
XYSeriesCollection dataset = new XYSeriesCollection(series);
return dataset;
}
#Override
public void chartMouseClicked(ChartMouseEvent event) {
// ignore
}
#Override
public void chartMouseMoved(ChartMouseEvent event) {
Rectangle2D dataArea = this.chartPanel.getScreenDataArea();
JFreeChart chart = event.getChart();
XYPlot plot = (XYPlot) chart.getPlot();
ValueAxis xAxis = plot.getDomainAxis();
double x = xAxis.java2DToValue(event.getTrigger().getX(), dataArea,
RectangleEdge.BOTTOM);
double y = DatasetUtilities.findYValue(plot.getDataset(), 0, x);
this.xCrosshair.setValue(x);
this.yCrosshair.setValue(y);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
#Override
public void run() {
CrosshairOverlayDemo1 app = new CrosshairOverlayDemo1(
"JFreeChart: CrosshairOverlayDemo1.java");
app.pack();
app.setVisible(true);
}
});
}
}

Plotting irregular-period data on time axis in JFreeChart

I am trying to create a line chart using JfreeChart API. The x axis receives data as long (milliseconds) and Y axis as a double.
As I am using the dynamic template I am passing data to it via Add_Point method from separate thread and chart is constantly updated via this method. Data comes in irregularly without any periodicity which perhaps makes it even trickier.
I cannot find a way to convert long into digestible for Jfreechart format without working example of it. It seems that I have exhausted all options but my guess is that there are a lot of people out there who have already been through this and have a ready answer.
All I want to do is to reflect correct time on X axis labels every minute with data points correctly spaced over respective point in time. By correct time I mean long value passed to method and not current system time.
Here is the code:
import java.awt.BorderLayout;
import javax.swing.JPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.plot.XYPlot;
import org.jfree.data.time.FixedMillisecond;
import org.jfree.data.time.Millisecond;
import org.jfree.data.time.RegularTimePeriod;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.xy.XYDataset;
import org.jfree.ui.ApplicationFrame;
public class DynamicDataDemo extends ApplicationFrame {
/** The time series data. */
private static TimeSeries series;
public DynamicDataDemo(final String title) {
super(title);
this.series = new TimeSeries("Random Data", Millisecond.class);
final TimeSeriesCollection dataset = new TimeSeriesCollection(this.series);
final JFreeChart chart = createChart(dataset);
final ChartPanel chartPanel = new ChartPanel(chart);
final JPanel content = new JPanel(new BorderLayout());
content.add(chartPanel);
chartPanel.setPreferredSize(new java.awt.Dimension(500, 270));
setContentPane(content);
}
private JFreeChart createChart(final XYDataset dataset) {
final JFreeChart result = ChartFactory.createTimeSeriesChart(
"Dynamic Data Demo",
"Time",
"Value",
dataset,
true,
true,
false
);
final XYPlot plot = result.getXYPlot();
ValueAxis axis = plot.getDomainAxis();
axis.setAutoRange(true);
axis.setFixedAutoRange(60000.0); // 60 seconds
axis = plot.getRangeAxis();
axis.setRange(9000.0, 11000.0);
return result;
}
public static void Add_Point(long x, double y){
series.add(new Millisecond(), y);
// series.add(new FixedMillisecond(x), y); }
}

If your x values are milliseconds from the Java epoch, you can do it like this:
series.add(new Millisecond(new Date(x)), y);
If not, you'll have to scale and/or offset the value.

JFreeChart - customizing RingChart

I want to make two ring charts that look like the following:
But the RingPlot doesn't seem very customizable. The best I could come up with is this:
Any chance of doing what I want with JFreeChart?

JFreeChart can do most things, this should get you started (I'll probably incorporate the center text feature into the upcoming 1.0.18 release so that the subclassing isn't necessary):
package org.jfree.chart.demo;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.geom.Rectangle2D;
import javax.swing.JPanel;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PiePlotState;
import org.jfree.chart.plot.RingPlot;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;
import org.jfree.text.TextUtilities;
import org.jfree.ui.ApplicationFrame;
import org.jfree.ui.HorizontalAlignment;
import org.jfree.ui.RectangleInsets;
import org.jfree.ui.RefineryUtilities;
import org.jfree.ui.TextAnchor;
/**
* A simple demonstration application showing how to create a ring chart using
* data from a {#link DefaultPieDataset}.
*/
public class RingChartDemo1 extends ApplicationFrame {
private static final long serialVersionUID = 1L;
static class CustomRingPlot extends RingPlot {
private Font centerTextFont;
private Color centerTextColor;
public CustomRingPlot(PieDataset dataset) {
super(dataset);
this.centerTextFont = new Font(Font.SANS_SERIF, Font.BOLD, 24);
this.centerTextColor = Color.LIGHT_GRAY;
}
#Override
protected void drawItem(Graphics2D g2, int section,
Rectangle2D dataArea, PiePlotState state, int currentPass) {
super.drawItem(g2, section, dataArea, state, currentPass);
if (currentPass == 1 && section == 0) {
Number n = this.getDataset().getValue(section);
g2.setFont(this.centerTextFont);
g2.setPaint(this.centerTextColor);
TextUtilities.drawAlignedString(n.toString(), g2,
(float) dataArea.getCenterX(),
(float) dataArea.getCenterY(),
TextAnchor.CENTER);
}
}
}
/**
* Default constructor.
*
* #param title the frame title.
*/
public RingChartDemo1(String title) {
super(title);
setContentPane(createDemoPanel());
}
/**
* Creates a sample dataset.
*
* #return A sample dataset.
*/
private static PieDataset createDataset() {
DefaultPieDataset dataset = new DefaultPieDataset();
dataset.setValue("A", new Double(210));
dataset.setValue("B", new Double(150));
return dataset;
}
/**
* Creates a chart.
*
* #param dataset the dataset.
*
* #return A chart.
*/
private static JFreeChart createChart(PieDataset dataset) {
CustomRingPlot plot = new CustomRingPlot(dataset);
JFreeChart chart = new JFreeChart("Custom Ring Chart",
JFreeChart.DEFAULT_TITLE_FONT, plot, false);
chart.setBackgroundPaint(new GradientPaint(new Point(0, 0),
new Color(20, 20, 20), new Point(400, 200), Color.DARK_GRAY));
// customise the title position and font
TextTitle t = chart.getTitle();
t.setHorizontalAlignment(HorizontalAlignment.LEFT);
t.setPaint(new Color(240, 240, 240));
t.setFont(new Font("Arial", Font.BOLD, 26));
plot.setBackgroundPaint(null);
plot.setOutlineVisible(false);
plot.setLabelGenerator(null);
plot.setSectionPaint("A", Color.ORANGE);
plot.setSectionPaint("B", new Color(100, 100, 100));
plot.setSectionDepth(0.05);
plot.setSectionOutlinesVisible(false);
plot.setShadowPaint(null);
return chart;
}
/**
* Creates a panel for the demo (used by SuperDemo.java).
*
* #return A panel.
*/
public static JPanel createDemoPanel() {
JFreeChart chart = createChart(createDataset());
chart.setPadding(new RectangleInsets(4, 8, 2, 2));
ChartPanel panel = new ChartPanel(chart);
panel.setMouseWheelEnabled(true);
panel.setPreferredSize(new Dimension(600, 300));
return panel;
}
/**
* Starting point for the demonstration application.
*
* #param args ignored.
*/
public static void main(String[] args) {
RingChartDemo1 demo = new RingChartDemo1("JFreeChart: Ring Chart Demo 1");
demo.pack();
RefineryUtilities.centerFrameOnScreen(demo);
demo.setVisible(true);
}
}