En temps réel des graphiques en Java

Si votre variable est mise à jour très vite, il n'y a aucun point dans la mise à jour d'un tableau à chaque fois.

Avez-vous pensé à la mise en mémoire tampon de la modification de la variable, et de l'actualisation de l'organigramme sur un thread différent, disons, tous les 5s ? Vous devriez trouver que JFreeChart peut gérer une telle vitesse de mise à jour.

Depuis JFreeChart est un bureau normal de la bibliothèque, vous pouvez l'intégrer en standard avec une application Swing très facilement. Ou, vous pouvez l'utiliser pour le graphique via une application web (par le rendu d'un fichier JPEG, PNG, etc. JFreeChart peut générer une image automatiquement les cartes, de sorte que vous pouvez utiliser mouseovers etc.)

OriginalL'auteur Brian Agnew

Si les données est mise à jour plus souvent que vous pouvez générer le graphique, alors vous devriez avoir une tâche dans un thread séparé qui régénère le graphique, et commence une autre régénération, quand c'est fait. Il y a peu de point dans l'exécution de ce minerai souvent que cela, mais si elle s'avère être trop de charge cpu, vous pouvez limiter la fréquence avec laquelle il redémarre. Si les mises à jour ne venez pas, vous ne déclenchent pas le re-générer. J'ai fait quelque chose comme ça dans mon Zocalo projet récemment. Il fait tout, mais l'étranglement arrière.

package net.commerce.zocalo.freechart;
//Copyright 2009 Chris Hibbert.  All rights reserved.
//This software is published under the terms of the MIT license, a copy
//of which has been included with this distribution in the LICENSE file.
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.Map;
import java.util.HashMap;
/**  Schedule a task like generating a price history graph.  Multiple requests may come
in sporadically.  We want to ensure that only one is being processed at a time.  If we're
busy processing when a request comes in, we'll remember to start another when this one is
done.  Multiple requests that come in while processing will spur a single restart. */
public class ChartScheduler {
static private Logger log = Logger.getLogger(ChartScheduler.class);
static private Map<String, ChartScheduler> schedulers = new HashMap<String, ChartScheduler>();
private AtomicBoolean generating = new AtomicBoolean(false);
private AtomicBoolean requested = new AtomicBoolean(false);
private ExecutorService threads = Executors.newCachedThreadPool();
private Callable<Boolean> callable;
private int runs = 0;
private String name;
private ChartScheduler(String name, final Runnable worker) {
this.name = name;
callable = new Callable<Boolean>() {
public Boolean call() throws Exception {
worker.run();
runs++;
restartIfNeeded();
return true;
}
};
}
public static ChartScheduler create(String name, Runnable worker) {
ChartScheduler sched = find(name);
if (sched == null) {
sched = new ChartScheduler(name, worker);
schedulers.put(name, sched);
}
return sched;
}
public static ChartScheduler find(String name) {
return schedulers.get(name);
}
public boolean generateNewChart() {
requested.set(true);
if (generating.compareAndSet(false, true)) {
startNewThread();
return true;
} else {
return false;
}
}
private Future<Boolean> startNewThread() {
generating.set(true);
requested.set(false);
return threads.submit(callable);
}
private boolean restartIfNeeded() {
generating.set(false);
if (requested.get()) {
return generateNewChart();
} else {
return false;
}
}
public boolean isBusy() {
return generating.get();
}
public int runs() {
return runs;
}
}

OriginalL'auteur PanCrit

Eh bien, je suis aussi à l'aide de JFreechart pour les hautes mises à jour. JFreeChart mises à jour jusqu'à 10 à 15 image/seconde, mais l'utilisation de 100% d'utilisation du PROCESSEUR. Mais si je veux le mettre à jour à une fréquence beaucoup plus élevée, il ne sera pas mis à jour. Si vous trouvez toute une bibliothèque qui peut être mis à jour à abt 20 fps et peut être utilisé pour développer une application en Java alors s'il vous plaît me suggérer aussi. J'ai vu de nombreux bibliothèque JFreeChart FAQ mais je ne suis pas sûr si quelqu'un pourrait être utiliser pour les mises à jour à environ 20 fps.

OriginalL'auteur

Afin d'obtenir votre CPU bien en dessous de 100% et de permettre à votre GUI d'être à l'écoute, vous devez limiter votre mise à jour des cartes de débit. Un maximum de taux de mise à jour d'environ 24 images par seconde a un sens pour un plan en temps réel; plus vite est plus ou moins impossible à distinguer de toute façon. Si vos données sont à venir dans plus vite que ce taux, vous avez juste besoin de tampon à l'arrière-plan et la mise à jour de votre graphique dans le premier plan à votre guise la vitesse de mise à jour. Dans l'exemple suivant, j'utilise XChart avec un SwingWorker thread d'arrière-plan. La saisie des données est simulé à un taux de un pour toutes les 5 ms et le graphique à jour à 24 images par seconde. Ce concept devrait travailler avec JFreeCharts ou de tout autre cartographie la bibliothèque avec de légères modifications. Avertissement: je suis le développeur principal de XChart.

import java.util.LinkedList;
import java.util.List;
import javax.swing.SwingWorker;
import org.knowm.xchart.QuickChart;
import org.knowm.xchart.SwingWrapper;
import org.knowm.xchart.XYChart;
/**
* Creates a real-time chart using SwingWorker
*/
public class SwingWorkerRealTime {
MySwingWorker mySwingWorker;
SwingWrapper<XYChart> sw;
XYChart chart;
public static void main(String[] args) throws Exception {
SwingWorkerRealTime swingWorkerRealTime = new SwingWorkerRealTime();
swingWorkerRealTime.go();
}
private void go() {
//Create Chart
chart = QuickChart.getChart("SwingWorker XChart Real-time Demo", "Time", "Value", "randomWalk", new double[] { 0 }, new double[] { 0 });
chart.getStyler().setLegendVisible(false);
chart.getStyler().setXAxisTicksVisible(false);
//Show it
sw = new SwingWrapper<XYChart>(chart);
sw.displayChart();
mySwingWorker = new MySwingWorker();
mySwingWorker.execute();
}
private class MySwingWorker extends SwingWorker<Boolean, double[]> {
LinkedList<Double> fifo = new LinkedList<Double>();
public MySwingWorker() {
fifo.add(0.0);
}
@Override
protected Boolean doInBackground() throws Exception {
while (!isCancelled()) {
fifo.add(fifo.get(fifo.size() - 1) + Math.random() - .5);
if (fifo.size() > 500) {
fifo.removeFirst();
}
double[] array = new double[fifo.size()];
for (int i = 0; i < fifo.size(); i++) {
array[i] = fifo.get(i);
}
publish(array);
try {
Thread.sleep(5);
} catch (InterruptedException e) {
//eat it. caught when interrupt is called
System.out.println("MySwingWorker shut down.");
}
}
return true;
}
@Override
protected void process(List<double[]> chunks) {
System.out.println("number of chunks: " + chunks.size());
double[] mostRecentDataSet = chunks.get(chunks.size() - 1);
chart.updateXYSeries("randomWalk", null, mostRecentDataSet, null);
sw.repaintChart();
long start = System.currentTimeMillis();
long duration = System.currentTimeMillis() - start;
try {
Thread.sleep(40 - duration); //40 ms ==> 25fps
//Thread.sleep(400 - duration); //40 ms ==> 2.5fps
} catch (InterruptedException e) {
}
}
}
}

OriginalL'auteur herrtim