Графическое отображение в реальном времени в Java

Ответ 1

Если ваша переменная обновляется так быстро, нет никакого смысла в обновлении графика каждый раз.

Задумывались ли вы о буферизации изменений переменных и обновлении графика в другом потоке, скажем, каждые 5 секунд? Вы должны обнаружить, что JFreeChart может хорошо обрабатывать такие скорости обновления.

Так как JFreeChart - обычная настольная библиотека, вы можете легко интегрировать ее со стандартным Swing-приложением. Или вы можете использовать его для составления диаграммы через веб-приложение (путем рендеринга в JPEG/PNG и т.д. JFreeChart также может автоматически создавать карты изображений, поэтому вы можете использовать мыши и т.д.).

Ответ 2

Если данные обновляются чаще, чем вы можете создать диаграмму, тогда у вас должна быть задача в отдельном потоке, который восстанавливает диаграмму и запускает другую регенерацию, когда это будет сделано. Там мало смысла запускать его чаще, чем в этом случае, но если он окажется слишком большим для процессора, вы можете отключить частоту, с которой он перезагружается. Если обновления не входят, вы не запускаете повторное создание. Недавно я сделал что-то подобное в моем проекте Zocalo. Он делает все, кроме дросселирования.

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;
    }
}

Ответ 3

Согласно этому сообщению в блоге:

http://jonathanwatmough.com/2008/02/prototyping-code-in-clojure/

его можно реализовать отображение "реального времени" звуковых спектров с использованием библиотеки KJ DSP:

http://sirk.sytes.net/software/libs/kjdss/index.htm

поэтому, если вы можете пройти с довольно простыми диаграммами, это может быть альтернативой JFreeChart.

Ответ 4

Отвечено раньше здесь. Ваша переменная изменяется до 50 раз в секунду, но в большинстве случаев вам не нужно обновлять каждый раз, когда происходит изменение. Вместо этого вы можете обновлять график через регулярные интервалы (например, каждые 100 мс).

Ответ 5

Возможно, вы можете использовать два потока. Один для обновления вашего приоритета переменной witch равен 10. И вторая нить, которая рисует так быстро, как возможный приоритет ведьмы, равна 5.

Мне пришлось делать то же самое в игре, которую я пишу.

Возможно, я не понял ваш вопрос.

Ответ 6

Ну, я также использую JFreechart для высоких обновлений. JFreeChart обновляет до 10-15 кадров в секунду, но использует 100% использование ЦП. Но если я хочу обновить его на гораздо более высокой частоте, он не будет обновлен. Если вы найдете какую-либо библиотеку, которая может быть обновлена ​​со скоростью 20 кадров в секунду и может быть использована для разработки приложения на Java, пожалуйста, предложите мне также. Я видел много библиотек JFreeChart FAQ, но я не уверен, может ли кто-нибудь использовать обновления со скоростью около 20 кадров в секунду.

Ответ 7

Вы должны попробовать диаграммы из VisualVM (часть JDK). Intro on: http://java.dzone.com/news/real-time-charts-java-desktop

Ответ 8

Чтобы ваш процессор оказался ниже 100% и ваш графический интерфейс оставался отзывчивым, вам необходимо снизить скорость обновления диаграммы. Максимальная скорость обновления около 24 кадров в секунду имеет смысл для графика в реальном времени; любой более быстрый, более или менее неотличимый в любом случае. Если ваши данные поступают быстрее, чем этот показатель, вам просто нужно закрепить его в фоновом режиме и обновить диаграмму на переднем плане с нужной скоростью обновления. В следующем примере я использую XChart вместе с фоновым потоком SwingWorker. Сбор данных моделируется со скоростью один раз в каждые 5 мс, а диаграмма обновляется со скоростью 24 кадра в секунду. Эта концепция должна работать с JFreeCharts или любой другой графической библиотекой, а также с небольшими изменениями. Отказ от ответственности: Я ведущий разработчик 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) {
      }

    }
  }
}