package com.developpez.realtimecharting.jfreechart;

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

public class JFreeChartRTCTest {

	/**
	 * The application shell
	 */
	private static Shell shell;

	/**
	 * The entry point method for the test.
	 * @param args : not used
	 */
	public static void main(String[] args) {
		/* 
		 * Create display and shell. 
		 * Assign application name, shell title and size.
		 */
		Display.setAppName("JFreeChart RTC SWT");
		Display display = new Display();
		shell = new Shell(display);
		shell.setText("JFreeChart Real Time Charting with SWT");
		shell.setMaximized(true);
		
		/* Open the shell maximized */
		shell.open();
		
		/* SWT display loop */
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch()) display.sleep();
		}
		display.dispose();
		
	}

}

package com.developpez.realtimecharting.jfreechart;

import java.awt.Color;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.XYPlot;
import org.jfree.data.Range;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.experimental.chart.swt.ChartComposite;
			
public class JFreeChartRTCTest {

	/**
	 * The number of charts that will be displayed
	 */
	private static int nbCharts = 1;
	
	/**
	 * The number of series per chart
	 */
	private static int nbSeriesPerChart = 1;

	/**
	 * An array of chart composite containing each JFree chart
	 */
	private static ChartComposite[] charts;
	
	/**
	 * The application shell
	 */
	private static Shell shell;

	/**
	 * This method create JFree chart XYSeries
	 * @param nbSeries number of series to be created in the chart
	 * @param chartComposite SWT chart composite containing the chart
	 */
	private static void createSeries(int nbSeries, ChartComposite chartComposite) {
		//Create XY Collection as usual with JFree chart
		XYSeriesCollection xySeriesCollection = new XYSeriesCollection();
		//Loop on series number
		for (int i = 0; i < nbSeries; i++) {
			//Create series
			XYSeries xySeries = new XYSeries("Serie" + (i+1), false, false);
			//Add created series to the collection of chart XY Series collection
			xySeriesCollection.addSeries(xySeries);
		}
		//Assign XY Series collection to chart data set
		((XYPlot)chartComposite.getChart().getPlot()).setDataset(xySeriesCollection);
	}
	
	/**
	 * This method creates charts area. A grid layout is assigned to the shell.
	 * If more than one chart will be displayed, grid layout will contain two columns.
	 * In each cell of the grid, a JFree chart XY Line is created and wrapped into a
	 * ChartComposite in order to be displayed with SWT. Finally, we create series
	 * in the current JFree chart.
	 */
	private static void createChartsArea() {
		shell.setLayout(new GridLayout((nbCharts>1?2:1), true));
		charts = new ChartComposite[nbCharts];
		//Loop on charts
		for (int i = 0; i < charts.length; i++) {
			//Create XY line chart
			JFreeChart jFreeChart = ChartFactory.createXYLineChart(null, null, null, null);
			//Some appearance
			jFreeChart.setBackgroundPaint(Color.BLACK);
			jFreeChart.getLegend().setBackgroundPaint(Color.BLACK);
			jFreeChart.getLegend().setItemPaint(Color.WHITE);
			((XYPlot)jFreeChart.getPlot()).setBackgroundPaint(Color.BLACK);
			((XYPlot)jFreeChart.getPlot()).getDomainAxis().setAutoRange(false);
			((XYPlot)jFreeChart.getPlot()).getDomainAxis().setRange(new Range(0, 10));
			((XYPlot)jFreeChart.getPlot()).getDomainAxis().setTickLabelPaint(Color.WHITE);
			((XYPlot)jFreeChart.getPlot()).getRangeAxis().setTickLabelPaint(Color.WHITE);
			((XYPlot)jFreeChart.getPlot()).setDomainGridlinesVisible(false);
			((XYPlot)jFreeChart.getPlot()).setRangeGridlinesVisible(false);
			jFreeChart.setAntiAlias(false);
			//Wrap JFree chart in a Chart composite
			charts[i] = new ChartComposite(shell, SWT.NONE, jFreeChart, false);
			charts[i].setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
			//Create series in this chart
			createSeries(nbSeriesPerChart, charts[i]);
		}
	}
	
	/**
	 * The entry point method for the test.
	 * @param args : not used
	 */
	public static void main(String[] args) {
		/* 
		 * Create display and shell. 
		 * Assign application name, shell title, size and layout.
		 */
		Display.setAppName("JFreeChart RTC SWT");
		Display display = new Display ();
		shell = new Shell (display);
		shell.setText("JFreeChart Real Time Charting with SWT");
		shell.setMaximized(true);
		
		/* Create charts area */
		createChartsArea();
		
		/* Open the shell to display charts */
		shell.open ();
		
		/* SWT display loop */
		while (!shell.isDisposed()) {
			if (!display.readAndDispatch()) display.sleep();
		}
		display.dispose();
		
	}

}

/**
 * This class generates data for each series of all charts.
 * It simulates 1000Hz sin data acquisition. Generation is called every
 * 100ms, producing 100 samples.
 */
private static class GenerateData extends TimerTask {
	
	/**
	 * Samples number
	 */
	private final int nbSamples = 100;
	
	/**
	 * Time (domain in JFreeChart) values
	 */
	private final Double[] time = new Double[nbSamples];
	
	/**
	 * Amplitude (range in JFreeChart) values
	 */
	private final Double[] y = new Double[nbSamples];
	
	/**
	 * Initial time values. Used when new samples are received.
	 */
	private double initialTime = -1/1000.0;
	
	/**
	 * This is the main method of the timer task. It generates 100 samples
	 * for each series that will be displayed in charts at a rate of 100ms.
	 * When this rate is not supported, each events will be delayed, as
	 * specified in Timer class documentation (<a href=
	 * "https://docs.oracle.com/javase/6/docs/api/java/util/Timer.html#schedule(java.util.TimerTask,%20long,%20long)"
	 * >see here</a>). These Delays will be visible on screen (display will jerk).
	 */
	@Override
	public void run() {
		//Loop on charts
		for (int numChart = 0; numChart < charts.length; numChart++) {
			
			final ChartComposite chart = charts[numChart];
			
			//Build time array
			for (int i = 0; i < time.length; i++) time[i] = initialTime + i/1000.0;
			
			//Updates must be done in SWT UI thread
			shell.getDisplay().syncExec(new Runnable() {
				@Override
				public void run() {
					//Loop on series
					final XYSeriesCollection xySeriesCollection = (XYSeriesCollection) ((XYPlot)chart.getChart().getPlot()).getDataset();
					for (int j = 0; j < xySeriesCollection.getSeriesCount(); j++) {
						final XYSeries serie = xySeriesCollection.getSeries(j);
						//Get series number in chart : it will be used as sin's frequency
						int frequency = Integer.parseInt(serie.getKey().toString().substring(serie.getKey().toString().length()-1)); 
						//Generate sin's samples
						for (int i = 0; i < y.length; i++) {
							y[i] = 5*Math.sin(2*Math.PI*(frequency/10.0)*time[i]);
							//Add sample to corresponding series, Update only when all samples have been added
							serie.add(time[i], y[i], ((i == y.length - 1)?true:false));
						}
					}
				}
			});

		}
		//Update initialTime for next series samples 
		initialTime = time[time.length - 1] + 1/1000.0;
		
		//Stop when 10s have been acquired
		if(initialTime > 10) {
			cancel();
			shell.getDisplay().asyncExec(new Runnable() {
				@Override
				public void run() {
					shell.close();
				}
			});
		}
	}
	
}

public static void main(String[] args) {
	/* 
	 * Create display and shell. 
	 * Assign application name, shell title, size and layout.
	 */
	Display.setAppName("JFreeChart SWT");
	Display display = new Display ();
	shell = new Shell (display);
	shell.setText("Real Time JFreeChart SWT");
	shell.setMaximized(true);
	
	/* Create charts area */
	createChartsArea();
	
	/* Open the shell to display charts */
	shell.open();
	
	/* Launch Data timer generation : generates data each 100ms */ 
	Timer timer = new Timer();
	GenerateData generateData = new GenerateData();
	timer.schedule(generateData, 1000, 100);
	
	/* SWT display loop */
	while (!shell.isDisposed()) {
		if (!display.readAndDispatch()) display.sleep();
	}
	display.dispose();
	
	/* Stop data timer */
	timer.cancel();

}

private ArrayList<Long> drawTimes = new ArrayList<Long>(0);

/**
* Return draw times : elapsed times between start and end of chart drawing 
* 
* @return an array of double containing elapsed times, in ms
*/
public double[] getDrawTimes() {
	double[] values = new double[drawTimes.size()];
  	for (int i = 0; i < values.length; i++) {
		values[i] = drawTimes.get(i);
	}
	return values;
}	

/**
...
*/
@Override public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor,
            PlotState parentState, PlotRenderingInfo info) {

long time = System.nanoTime();
...
...
drawTimes.add(System.nanoTime() - time);

}

...
//Stop when 10s have been acquired
if(initialTime > 10) {
	cancel();
	
	//Retrieve all draw times of each chart, saving them in an HashMap
	HashMap<Integer, double[]> drawTimesMap = new HashMap<Integer, double[]>(); 
	for (int numChart = 0; numChart < charts.length; numChart++) {
		final ChartComposite chart = charts[numChart];
		double[] drawTimes = chart.getChart().getXYPlot().getDrawTimes();
		drawTimesMap.put(numChart, drawTimes);
	}
	
	//Compute some statistics on these values
	Statistics.compute(drawTimesMap, nbCharts, nbSeriesPerChart, "JF");
	
	//Close application
	shell.getDisplay().asyncExec(new Runnable() {
		@Override
		public void run() {
			shell.close();
		}
	});
}
...

package com.developpez.realtimecharting;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.HashMap;

import org.apache.commons.math3.stat.StatUtils;

/**
 * Compute statistics like mean, variance and quartiles
 */
public final class Statistics {
	
	/**
	 * 
	 * @param drawTimesMap : hashMap containing all the display elasped times
	 * @param nbCharts : the number of charts in the shell
	 * @param nbSeriesPerChart : the number of series per chart
	 * @param library : the library for which we compute these statistics ("JF" : JFreeChart)
	 */
	public static void compute(HashMap<Integer, double[]> drawTimesMap, int nbCharts, int nbSeriesPerChart, String library) {
		//Assume there are always the same number of drawing events for each chart
		int nbDrawEvents = ((double[])drawTimesMap.get(0)).length;
		
		//An array which will contains these values, 
		//summed when there are more than one chart
		double[] totalValues = new double[nbDrawEvents];
		for (double[] values : drawTimesMap.values()) {
		   for (int i = 0; i < values.length; i++) {
			   totalValues[i] = totalValues[i]  + values[i];
		   }
		}

		//Compute statistics 
		double mean = StatUtils.mean(totalValues);
		double stdDev = Math.sqrt(StatUtils.variance(totalValues));
		double min = StatUtils.min(totalValues);
		double max = StatUtils.max(totalValues);
		double quartile1 = StatUtils.percentile(totalValues, 25);
		double median = StatUtils.percentile(totalValues, 50);
		double quartile3 = StatUtils.percentile(totalValues, 75);
		String condition = "C" + nbCharts + "S" + nbSeriesPerChart + library;
		
		//Display results in console
		System.out.printf("Condition : %s\n", condition);
		System.out.printf("nbDrawEvents : %d\n", nbDrawEvents);
		System.out.printf("min : %f ms\n", + min);
		System.out.printf("quartile1 : %f ms\n", quartile1);
		System.out.printf("mean : %f ms\n", mean);
		System.out.printf("median : %f ms\n", median);
		System.out.printf("quartile3 : %f ms\n", quartile3);
		System.out.printf("max : %f ms\n", max);
		System.out.printf("stdDev : %f ms", stdDev);
		
	}

}

/*
 *  Arguments (if not null) : nb chart, nb series per chart, 
 * file name and create or append to results file 
 */
public static void main(String[] args) {
	
	/* Arguments (if not null) : nb chart, nb series per chart, 
	file name and create or append to results file */
	if(args != null && args.length == 4) {
		nbCharts = Integer.parseInt(args[0]);
		nbSeriesPerChart = Integer.parseInt(args[1]);
		resultFileName = args[2];
		createResultFile = Boolean.parseBoolean(args[3]);
	}
...

...
/**
 * 
 * @param drawTimesMap : hashMap containing all the display elasped times
 * @param nbCharts : the number of charts in the shell
 * @param nbSeriesPerChart : the nomber of series per chart
 * @param resultFileName : the results file's name, or null 
 * @param createResultFile : create or append to results file's name. No used if resultFileName is null
 * @param library : the library for which we compute these statistics ("JF" : JFreeChart)
 */
public static void compute(HashMap<Integer, double[]> drawTimesMap, int nbCharts, int nbSeriesPerChart, String resultFileName, boolean createResultFile, String library) {
	//Assume there are always the same number of drawing events for each chart
	int nbDrawEvents = ((double[])drawTimesMap.get(0)).length;

...

	System.out.printf("max : %f ms\n", max);
	System.out.printf("stdDev : %f ms", stdDev);
	
	/* Create or append to result file if necessary */
	if(resultFileName != null) {
		try {
			//We only need two decimals
			NumberFormat formatter = new DecimalFormat("#0.00"); 
			File resultFile = new File(resultFileName);
			//If results file must be created, delete it if it exists
			if(createResultFile && resultFile.exists()) resultFile.delete();
			//Create PrintWriter for results file
			PrintWriter printWriter = new PrintWriter(new FileOutputStream(resultFile, !createResultFile));
			//If results file must be created, print header
			if(createResultFile) printWriter.println("Condition\tnbDrawEvents\tmin(ms)\tQ1(ms)\tmean(ms)\tmedian(ms)\tQ3(ms)\tmax(ms)\tstdDev(ms)");
			//Print results
			printWriter.printf("%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", condition, nbDrawEvents , formatter.format(min), formatter.format(quartile1), 
					   					   formatter.format(median), formatter.format(quartile3), formatter.format(max), 
					   					   formatter.format(mean), formatter.format(stdDev));
			//Close file
			printWriter.flush();
			printWriter.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
...

package com.developpez.realtimecharting;

import com.developpez.realtimecharting.jfreechart.JFreeChartRTCTest;

/**
 * 
 * @author frank buloup
 *
 */
public class AllTests {
	
	public static void main(String[] args) {
		
		try {
			
			String resultsFile = "results.txt";
			
			//Condition C1S1
			JFreeChartRTCTest.main(new String[]{"1", "1", resultsFile, "true"});
			Thread.sleep(100);
			//Condition C1S2
			JFreeChartRTCTest.main(new String[]{"1", "2", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C1S3
			JFreeChartRTCTest.main(new String[]{"1", "3", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C1S4
			JFreeChartRTCTest.main(new String[]{"1", "4", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C2S1
			JFreeChartRTCTest.main(new String[]{"2", "1", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C2S2
			JFreeChartRTCTest.main(new String[]{"2", "2", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C2S3
			JFreeChartRTCTest.main(new String[]{"2", "3", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C2S4
			JFreeChartRTCTest.main(new String[]{"2", "4", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C4S1
			JFreeChartRTCTest.main(new String[]{"4", "1", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C4S2
			JFreeChartRTCTest.main(new String[]{"4", "2", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C4S3
			JFreeChartRTCTest.main(new String[]{"4", "3", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C4S4
			JFreeChartRTCTest.main(new String[]{"4", "4", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C6S1
			JFreeChartRTCTest.main(new String[]{"6", "1", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C6S2
			JFreeChartRTCTest.main(new String[]{"6", "2", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C6S3
			JFreeChartRTCTest.main(new String[]{"6", "3", resultsFile, "false"});
			Thread.sleep(100);
			//Condition C6S4
			JFreeChartRTCTest.main(new String[]{"6", "4", resultsFile, "false"});
			Thread.sleep(100);
			
			System.exit(0);
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

}