Letysite.ru

IT Новости с интернет пространства
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Программирование графики на java

Java Swing 2D. Введение

Обзор Java 2D API

Графический интерфейс джава довольно развит и включает классы графического вывода,методы работы с цветом, вывод контуров, фигур, изображений и текста, работу с областью отсечения, преобразование координат, и различные вспомогательные классы.

основные классы графического интерфейса

  • Graphics2D (расширение Graphics) — контекст вывода. Определяет текущее графическое состояние, а также методы графического вывода. Для обратной совместимости другие классы в определении своих методов указывают Graphics, хотя реально используют Graphics2D;
  • Color — цвет;
  • Font — шрифт;
  • Point (расширение Point2D) — точка;
  • Rectangle — четырехугольник;
  • Polygon — многоугольник;
  • BasicStroke — контур сложной духмерной фигуры;
  • AffineTransform — матрица преобразования координат;
  • BufferedImage (расширение Image) — изображение, можно использовать также для вне экранного вывода совместо с Graphics2D;
  • TexturePaint — используется для заполнения фигуры текстурой;
  • GradientPaint — используется для градиентного заполнения фигуры.

Цвет реализуется классом Color. В нем также определены статические члены стандартных цветов, как Color.white. Ниже приведен список методов Graphics2D для работы с цветом:

  • getBackground — получить цвет очищения области;
  • setBackground — установить цвет очищения области;
  • clearRect — очистить область;
  • setColor — установить текущий цвет вывода;
  • getColor — получить текущий цвет вывода;

фигуры

Поддерживаются следующие классы фигур:

  • Arc2D — дуга;
  • Area — область, составная фигура (например, четырехугольник минус эллипс);
  • CubicCurve2D — сегмент кубической кривой (сплайн);
  • Ellipse2D — эллипс;
  • QuadCurve2D — сегмент квадратичной кривой (сплайн);
  • Line2D — линия;
  • Rectangle2D — четырехугольник;
  • RoundRectangle2D — четырехугольник с закругленными углами;
  • Rectangle — четырехугольник;
  • Polygon — многоугольник;
  • BasicStroke — контур сложной духмерной фигуры.

Все эти классы реализуют интерфейс Shape:

  • contains — методы определения содержится ли указанная точка или четырехугольник внутри сложной фигуры;
  • intersects — определяет, пересекается ли сложная фигура с четырехугольником;
  • getBounds — возвращает ограничивающий сложную фигуру четырехугольник;
  • getPathIterator — возвращает итератор по сегментам сложной фигуры.

Ниже приведен список методов Graphics2D для вывода фигур. Методы с префиксом draw выводят контур фигуры, а с префиксом fill закрашенную фигуру. Кроме цвета для закраски могут использоваться изображения или цветовые градиенты, реализуемые классами TexturePaint, GradientPaint.

  • draw — сложная фигура;
  • draw3DRect — трехмерный четырехугольник;
  • drawArc — дуга;
  • drawLine — линия, также используется для вывода точки;
  • drawPolyline — вывод последовательности линий;
  • drawOval — овал;
  • drawPolygon — многоугольник;
  • drawRect — четырехугольник;
  • drawRoundRect — четырехугольник с закругленными углами.
  • fill — сложная фигура;
  • fill3DRect — трехмерный четырехугольник;
  • fillArc — дуга;
  • fillOval — овал;
  • fillPolygon — многоугольник;
  • fillRect — четырехугольник;
  • fillRoundRect — четырехугольник с закругленными углами.

текст и изображения

Методы Graphics2D для вывода символов и изображения:

  • drawBytes, drawChars — вывод символов;
  • drawString — вывод строки;
  • drawImage — вывод изображения.

преобразование координат

Методы Graphics2D для преобразование координат:

  • getTransform — получить копию текущей матрицы преобразований;
  • setTransform — установить матрицу преобразований;
  • rotate — добавление вращения к текущей матрице;
  • scale — добавление масштабирования к текущей матрице;
  • shear — добавления скоса к текущей матрице;
  • translate — добавление сдвига к текущей матрице.

область отсечения

Методы Graphics2D для работы с областью отсечения:

  • setClip — установить текущую область отсечения;
  • getClip — получить текущую область отсечения;
  • getClipBounds — получить четырехугольник окружающий область отсечения;
  • clipRect — сделать пересечение с текущией областью отсечения новой областью;
  • clip — сделать пересечение сложной фигуры с текущей областью отсечения новой областью.

интерактивность

Методы Graphics2D для интерактивности с пользователем:

  • hit — есть ли пересечение между фигурой и четырехугольником;
  • hitClip — есть ли пересечение между областью отсечения и четырехугольником;
  • дополнительно см. методы интерфейса Shape.

Пример вывода графики с помощью Swing 2D

Контекст вывода Graphics или Graphics2D забирает много системных ресурсов. Поэтому если вы их создаете явно из другого Graphics, компонента, BufferedImage и т.п. (обычно это метод getGraphics), то рекомендуется освободить ресурсы явно вызовом метода dispose.

Для вывода пользовательской графики обычно создается отдельный элемент управления, который затем размещается на главное окно. В нем перегружается метод paintComponent для Swing элементов, или методы paint и update для awt элементов.
В этих случаях ресурсы контекста вывода освобождаются автоматически.

Для сохранения родительского облика в методе можно сделать вызов super.paintComponent(g);. И далее дорисовать поверх. Для примера в нижеследующем коде замените JComponent на JButton и удалите очищение фона.

Работа с изображениями в Swing 2D

Изображения в java описываются классом BufferedImage, который объединяет в себе объект растровых данных Raster и объект цветовой модели ColorModel.

В свою очередь объект растровых данных состоит из объекта DataBuffer, содержащего
четырехугольный массив значений пикселей, и объекта SampleModel, описывающего организацию данных в массиве: число банков в DataBuffer, ширину и высоту изображения, тип значений в DataBuffer (например, TYPE_INT).

Объект ColorModel нужен для преобразования данных пикселя в значения составляющих цвета.

вывод в изображение

Для вывода в изображение всего лишь надо получить контекст вывода изображения. Например, в следующем коде создается изображение белого многоугольника на сиреневом фоне.

вывод изображения

Для вывода изображения в объекте контекста вывода Graphics2d есть несколько методов. Для краткости я опущу типы аргументов:

  • drawImage(img, x, y, observer)
  • drawImage(img, x, y, bgcolor,observer)
  • drawImage(img, x, y, width, height, bgcolor, observer)
  • drawImage(img, x, y, width, height, observer)
  • drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, bgcolor, observer)
  • drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observer)

Первый аргумент везде само изображение.

x, y, width, height — четырехугольная область вывода.

dx1, dy1, dx2, dy2 — координаты четырехугольной области вывода.

sx1, sy1, sx2, sy2 — координаты четырехугольной части изображения, которая будет выведена.

В качестве значения аргумента observer можно указывать null. Данный аргумент нужен только при асинхронной работе с изображением.

bgcolor — цвет заднего фона для прозрачных частей изображения.

Если область вывода не соответствует выводимой части изображения, то растровые данные автоматически масштабируются.

Графические форматы файлов.

Для манипуляций с графическими файлами в Java определен класс ImageIO.
При чтении ImageIO сам определяет формат файла. Список поддерживаемых форматов зависит от реализации Java, однако гарантируется поддержка jpeg, png, gif, bmp и wbmp. Список поддерживаемых форматов можно получить вызовом ImageIO.getWriterFormatNames()

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

Графика в Java. Graphics

Графический контекст компонентов

Графику в Java обслуживают классы Graphics и Graphics2D.

Работа с графикой осуществляется в графическом контексте элементов, унаследованных от класса Component. Понимать это можно так: на элементах управления, например, JFrame, JPanel, JButton и других, есть возможность рисовать. Такие элементы обладают графическим контекстом, в этом контескте мы и рисуем. Всё, что нарисуем в контексте будет показано на элементе. Классы Graphics и Graphics2D нужны для работы с графическим контекстом. Мы должны получить экземпляр такого класса и, используя его методы, рисовать. Получить экземпляр контекста можно в методе paint:

этот метод наследуется из класса Component. Аргумент Graphics g создаётся системой, а мы берём его в готовом виде и используем для рисования. При создании элемента метод paint будет вызван автоматически.

Начнём изучать работу с графикой в Java с класса Graphics.

Graphics

Рассмотрим простой пример использования методов класса Graphics в Java:

Получаем:

Ниже разбираются все методы, использованные в примере.

Как начертить прямую линию?

Метод drawLine класса Graphics начертит прямую линию:

здесь 20, 30 — это координаты x, y начала линии,
360, 30 — координаты конца линии.

Как задать цвет?

Метод setColor класса Graphics сделает текущим новый цвет:

Аргументы конструктора new Color(0, 0, 255) — это красный, зелёный и синий цвета соответственно (rgb).

Как задать rgb цвета? В примере задан чисто синий цвет, т.к. значения других составляющих равны нулю. Вот чисто красный цвет:

Читать еще:  Ошибка в данных

А это чисто зеленый цвет:

Значения составляющих цвета изменяются от 0 до 255.

Светло-синий цвет, который мы использовали для заливки прямоугольника:

Как задать цвет фона?

Задать цвет фона можно методом setBackground:

Как нарисовать прямоугольник?

Методом drawRect класса Graphics:

20, 40 — это координаты верхнего левого угла прямоугольника;
340 — длина;
20 — высота прямоугольника.

Как залить прямоугольник цветом?

Методом fillRect класса Graphics:

Как нарисовать прямоугольник с закругленными углами?

Методом drawRoundRect класса Graphics.

Сопряжение, т.е. закругление на углах, делается с помощью частей овала.

первые 4 аргумента как у обычного прямоугольника. Пятый аргумент — 20 — это ширина прямоугольника, в который вписана часть овала сопряжения. Шестой аргумент — 15 — это высота прямоугольника, в который вписана часть овала сопряжения.

Как нарисовать овал?

Методом drawOval класса Graphics:

Аргументы определяют прямоугольник, в который вписан овал.

Как нарисовать окружность?

Методом drawOval класса Graphics:

Аргументы определяют прямоугольник, в который вписана окружность. Здесь рисуем овал, но длина и высота описанного прямоугольника равны, что и даёт окружность.

Как нарисовать дугу?

Методом drawArc класса Graphics:

первые 4 аргумента как у обычного прямоугольника. Пятый аргумент — 0 — это угол, от которого отсчитывается угол самой дуги. 180 — это угол дуги. Углы отсчитывают от горизонтальной оси: по часовой стрелке отрицательное направление, протв — положительное. В примере 180 градусов (величина дуги) отсчитываем от горизонтальной линии.

Как нарисовать многоугольник?

Методом drawPolygon класса Graphics:

Здесь создаём объект класса Polygon. arrayX — это х-координаты вершин многоугольника, arrayY — это y-координаты вершин многоугольника, 8 — число вершин многоугольника.

Как создать объект точки?

Для этого используем класс Point:

аргументы — это x, y координаты.

Как определить, что точка принадлежит многоугольнику?

Используем метод класса Polygon contains для определения лежит ли точка в многоугольнике.

Как вывести строку?

Методом drawString класса Graphics:

строка «Yes» будет выведена от точки с координатами 50, 190.

Как задать шрифт?

Для этого используем класс Font:

где «Tahoma» — название шрифта,
Font.BOLD|Font.ITALIC — жирный шрифт с наклоном,
40 — высота шрифта.

После задания шрифта мы делаем его текущим и выводим строку этим шрифтом:

Как задать цвет текста?

Чтоб задать цвет текста создадим и установим в графический контекст новый цвет:

Здесь мы создали чисто синий цвет. А теперь выводим строку синим цветом:

Как начертить график?

Как график функции начертить? Сначала начертим координатные оси:

А теперь построить график функции можно просто. Для этого используем метод drawPolyline класса Graphics:

График строим по точкам, xArray – это x-координаты точек, yArray – y-координаты точек графика, nPoint — это число точек.

Наш график являет собой кривую намагничивания. Но почему график такой угловатый (см. картинку выше)? Если взять больше точек, то график будет более плавным.

Создание движка для 3D-рендеринга на Java

    Переводы, 10 марта 2016 в 23:38

Современные движки для 3D-рендеринга, использующиеся в играх и мультимедиа, поражают своей сложностью в плане математики и программирования. Соответственно, результат их работы превосходен.

Многие разработчики ошибочно полагают, что создание даже простейшего 3D-приложения с нуля требует нечеловеческих знаний и усилий. К счастью, это не совсем так. Более того, при наличии компьютера и свободного времени, можно создать нечто подобное самостоятельно. Давайте взглянем на процесс разработки нашего собственного движка для 3D-рендеринга.

Итак, для чего же это всё нужно? Во-первых, создание движка для 3D-рендеринга поможет понять, как же работают современные движки изнутри. Во-вторых, сам движок при желании можно использовать и в своём собственном приложении, не прибегая к вызову внешних зависимостей. В случае с Java это значит, что вы можете создать своё собственное приложение для просмотра 3D-изображений без зависимостей (далёких от API Java), которое будет работать практически везде и уместится в 50 КБ!

Само собой, если вы хотите создать какое-нибудь большое 3D-приложение с плавной анимацией, вам лучше использовать OpenGL/WebGL. Однако, имея базовое представление о том, как устроены подобные движки, работа с более сложными движками будет казаться в разы проще.

LATOKEN, Москва, от 3500 до 5000 $

В этой статье я постараюсь объяснить базовый 3D-рендеринг с ортографической проекцией, простую треугольную растеризацию (процесс, обратный векторизации), Z-буферизацию и плоское затенение. Я не буду заострять своё внимание на таких вещах, как оптимизация, текстуры и разные настройки освещения — если вам это нужно, попробуйте использовать более подходящие для этого инструменты, вроде OpenGL (существует множество библиотек, позволяющих вам работать с OpenGL, даже используя Java).

Примеры кода будут на Java, но сами идеи могут, разумеется, быть применены для любого другого языка по вашему выбору.

Довольно болтать — давайте приступим к делу!

Для начала, давайте поместим хоть что-нибудь на экран. Для этого, я буду использовать простое приложение, в котором будет отображаться наше отрендеренное изображение и два скроллера для вращения.

Результат должен выглядеть вот так:

Теперь давайте добавим некоторые модели — вершины и треугольники. Вершина — это просто структура для хранения наших трёх координат (X, Y и Z), а треугольник соединяет вместе три вершины и содержит их цвет.

Здесь я буду считать, что X означает перемещение влево-вправо, Y — вверх-вниз, а Z будет глубиной (так, что ось Z перпендикулярна вашему экрану). Положительная Z будет означать «ближе к пользователю».

В качестве примера я выбрал тетраэдр как простейшую фигуру, о которой вспомнил — нужно всего 4 треугольника, чтобы описать её.

Код также будет достаточно простым — мы просто создаём 4 треугольника и добавляем их в ArrayList:

В результате мы получим фигуру, центр которой находится в начале координат (0, 0, 0), что довольно удобно, так как мы будем вращать фигуру относительно этой точки.

Теперь давайте добавим всё это на экран. Сперва мы не будем добавлять возможность вращения и просто отрисуем каркасное представление фигуры. Так как мы используем ортографическую проекцию, это довольно просто — достаточно убрать координату Z и нарисовать наши треугольники.

Заметьте, что сейчас я совершил все преобразования до отрисовки треугольников. Это сделано, чтобы для того, что бы поместить наш центр (0, 0, 0) в центр экрана — по умолчанию начало координат находится в левом верхнем углу экрана. После компиляции вы должны получить:

Вы можете не поверить, но это наш тетраэдр в ортогональной проекции, честно!

Теперь нам нужно добавить вращение. Для этого мне нужно будет немного отойти от темы и поговорить об использовании матриц и о том, как с их помощью достичь трёхмерной трансформации 3D-точек.

Существует много путей манипулировать 3D-точками, но самый гибкий из них — это использование матричного умножения. Идея заключается в том, чтобы показать точки в виде вектора размера 3×1, а переход — это, собственно, домножение на матрицу размера 3×3.

Возьмём наш входной вектор A:

И умножим его на так называемую матрицу трансформации T, чтобы получить в итоге выходной вектор B:

Например, вот как будет выглядеть трансформация, если мы умножим на 2:

Вы не можете описать любую возможную трансформацию, используя матрицы размера 3×3 — например, если переход происходит за пределы пространства. Вы можете использовать матрицы размера 4×4, делая перекос в 4D-пространство, но об этом не в этой статье.

Трансформации, которые нам пригодятся здесь — масштабирование и вращение.

Любое вращение в 3D-пространстве может быть выражено в 3 примитивных вращениях: вращение в плоскости XY, вращение в плоскости YZ и вращение в плоскости XZ. Мы можем записать матрицы трансформации для каждого из данных вращений следующим путём:

И вот здесь начинается магия: если вам нужно сначала совершить вращение точки в плоскости XY, используя матрицу трансформации T1, и затем совершить вращение этой точки в плоскости YZ, используя матрицу трансформации T2, то вы можете просто умножить T1 на T2 и получить одну матрицу, которая опишет всё вращение:

Читать еще:  Ошибка входа в ютуб

Это очень полезная оптимизация — вместо того, чтобы постоянно считать вращения на каждой точке, мы заранее считаем одну матрицу и затем используем её.

Что ж, довольно страшной математики, давайте вернёмся к коду. Создадим служебный класс Matrix3, который будет обрабатывать перемножения типа “матрица-матрица” и “вектор-матрица”:

Теперь можно и оживить наши скроллеры вращения. Горизонтальный скроллер будет контролировать вращение влево-вправо (XZ), а вертикальный скроллер будет контролировать вращение вверх-вниз (YZ).

Давайте создадим нашу матрицу вращения:

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

Как вы, наверное, уже заметили, вращение вверх-вниз ещё не работает. Добавим эти строки в код:

До сих пор мы отрисовывали только каркасное представление нашей фигуры. Теперь давайте заполним его чем-нибудь. Для этого нам нужно сначала растеризовать треугольник — представить его в виде пикселей на экране.

Я буду использовать очень простой, но крайне неэффективный метод — растеризация через барицентрические координаты. Настоящие 3D-движки используют растеризацию, задействуя железо компьютера, что очень быстро и эффективно, но мы не можем использовать нашу видеокарту, так что будем делать всё вручную, через код.

Идея заключается в том, чтобы посчитать барицентрическую координату для каждого пикселя, который может лежать внутри нашего треугольника и исключить те, что вне его пределов. Следующий фрагмент содержит алгоритм. Обратите внимание на то, как мы стали напрямую обращаться к пикселям изображения.

Довольно много кода, но теперь у нас есть цветной тетраэдр на экране.

Если вы поиграетесь с демкой, то вы заметите, что не всё сделано идеально — например, синий треугольник всегда выше других. Так происходит потому, что мы отрисовываем наши треугольники один за другим. Синий здесь — последний, поэтому он отрисовывается поверх других.

Чтобы исправить это, давайте рассмотрим Z-буферизацию. Идея состоит в том, чтобы в процессе растеризации создать промежуточный массив, который будет хранить в себе расстояние до последнего видимого элемента на каждом из пикселей. Делая растеризацию треугольников, мы будем проверять, меньше ли расстояние до пикселя, чем расстояние до предыдущего, и закрашивать его только в том случае, если он находится поверх других.

Теперь видно, что у нашего тетраэдра есть одна белая сторона:

Вот мы и получили работающий движок для 3D-рендеринга!

Но и это ещё не конец. В реальном мире восприятие какого-либо цвета меняется в зависимости от положения источников света — если на поверхность падает лишь небольшое количество света, то она видится более темной.

В компьютерной графике мы можем достичь подобного эффекта с помощью так называемого «затенения» — изменения цвета поверхности в зависимости от угла наклона и расстояния относительно источника света.

Простейшая форма затенения — это плоское затенение. Этот способ учитывает только угол между поверхностью, нормаль и направление источника света. Вам всего лишь нужно найти косинус угла между двумя векторами и умножить цвет на получившееся значение. Такой подход очень прост и эффективен, поэтому он часто используется для высокоскоростного рендеринга, когда наиболее продвинутые технологии затенения слишком неэффективны.

Для начала нам нужно посчитать вектор нормали для нашего треугольника. Если у нас есть треугольник ABC, мы можем посчитать его вектор нормали, рассчитав векторное произведение векторов AB и AC и поделив получившийся вектор на его длину.

Векторное произведение — это бинарная операция на двух векторах, которые определены в 3D пространстве вот так:

Вот так выглядит визуальное представление того, что делает наше векторное произведение:

Теперь нам нужно посчитать косинус между нормалью треугольника и направлением света. Для упрощения будем считать, что наш источник света расположен прямо за камерой на каком-либо расстоянии (такая конфигурация называется «направленный свет») — таким образом, наш источник света будет находиться в точке (0, 0, 1).

Косинус угла между векторами можно посчитать по формуле:

Где ||A|| — длина вектора, а числитель — скалярное произведение векторов A и B:

Обратите внимание на то, что длина вектора направления света равна 1, так же, как и длина нормали треугольника (мы уже нормализовали это). Таким образом, формула просто превращается в это:

Заметьте, что только Z компонент направления света не равен нулю, так что мы можем просто всё упростить:

В коде это всё выглядит тривиально:

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

Теперь, получив наш коэффициент затенения, мы можем применить его к цвету нашего треугольника. Простой вариант будет выглядеть как-то так:

Код будет давать нам некоторые эффекты затенения, но спадать они будут куда быстрее, чем нам нужно. Так происходит, потому что в Java используется спектр цветов sRGB.

Так что нам нужно конвертировать каждый цвет в линейный формат, применить затенение и затем конвертировать обратно. Реальный переход из sRGB к линейному RGB — довольно трудоёмкий процесс, так что я не буду выполнять полный перечень задач здесь. Вместо этого, я сделаю нечто приближенное к этому.

И теперь мы видим, как наш тетраэдр оживляется. У нас есть работающий движок для 3D рендеринга с цветами, освещением, затенением, и заняло это около 200 строк кода — неплохо!

Вот небольшой бонус для вас — вы можете быстро создать фигуру, приближенную к сфере из своего тетраэдра. Этого можно достичь путём разбивания каждого треугольника на 4 маленьких и «надувая».

Вот что должно у вас получиться:

Я бы закончил эту статью, порекомендовав одну занимательную книгу: “Основы 3D-математики для графики и разработки игр”. В ней вы можете найти детальное объяснение процесса рендеринга и математики в этом процессе. Её стоит прочитать, если вам интересны движки для рендеринга.

График в реальном времени на Java

У меня есть приложение, которое обновляет переменную от 5 до 50 раз в секунду, и я ищу какой-то способ рисования непрерывного XY-графика этого изменения в режиме реального времени.

хотя JFreeChart не рекомендуется для такой высокой скорости обновления, многие пользователи по-прежнему говорят, что он работает для них. Я пробовал использовать этой demo и изменил его для отображения случайной величины, но, похоже, все время использует 100% использование процессора. Даже если я проигнорирую это, я не хочу быть ограничен классом пользовательского интерфейса JFreeChart для построения форм (хотя я не уверен, каковы его возможности). Можно ли интегрировать его с «формами» и раскрывающимися меню Java? (как доступны в VB) в противном случае, есть ли какие-либо альтернативы, которые я мог бы изучить?

EDIT: Я новичок в Swing, поэтому я собрал код, чтобы проверить функциональность JFreeChart с ним (избегая при этом использования класса ApplicationFrame JFree, так как я не уверен как это будет работать с комбо-боксами и кнопками Swing). Сейчас график будет немедленно обновлена и ЦП. Можно ли буферизировать значение с помощью new Millisecond () и обновлять его, возможно, дважды в секунду? Кроме того, могу ли я добавить другие компоненты к остальной части JFrame без нарушения JFreeChart? Как мне это сделать? рамка.getContentPane ().добавить (новая кнопка («Click»)), кажется, перезаписывает график.

8 ответов

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

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

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

Читать еще:  Ошибка 0 80240017

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

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

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

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

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

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

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

для того, чтобы получить ваш процессор намного ниже 100% и позволить вашему GUI оставаться отзывчивым, вы должны дросселировать скорость обновления диаграммы. Максимальная скорость обновления около 24 кадров в секунду имеет смысл для графика в реальном времени; любой быстрее более или менее неразличим в любом случае. Если ваши данные поступают быстрее, чем эта скорость, вам просто нужно буферизировать их в фоновом режиме и обновить диаграмму на переднем плане с требуемой скоростью обновления. В следующем примере я использую XChart вместе с SwingWorker фоновый поток. Захват данных моделируется со скоростью один на каждые 5 мс, а график обновляется со скоростью 24 кадров в секунду. Эта концепция должна работать с jfreecharts или любой другой библиотекой диаграмм, а также с небольшими изменениями. Отказ от ответственности: я ведущий разработчик XChart.

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

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

Библиотека JFreeChart

Проект JFreeChart был основан в феврале 2000 года Дэвидом Гилбертом. Сегодня библиотека JFreeChart широко используется в Java приложениях для создания широкого спектра графиков. Используя JFreeChart можно создавать все основные типы 2D и 3D графики : круговые диаграммы, гистограммы, линейные и временные диаграммы. Библиотека позволяет создавать изображения нескольких форматов типа PNG, JPEG, SVG (Scalable Vector Graphics) и т.д.

JFreeChart обеспечена хорошо документированным API, поставляется с открытым исходным кодом и бесплатно. Это позволяет использовать ее в коммерческих целях без каких-либо дополнительных затрат. Документированное описание API можно найти на официальном сайте http://www.jfree.org/jfreechart/api/javadoc.

Дистрибутив JFreeChart

Дистрибутив библиотеки JFreeChart поставляется в виде zip файла и включает maven проект с документацией и демонстрационными примерами. Скачать последнюю версию библиотеки JFreeChart можно с официального сайта http://www.jfree.org/jfreechart/download.html.

Загрузка JFreeChart в maven репозиторий

Артефакт JFreeChart версии 1.0.19 можно найти в репозитории mvnrepository по следующим GAV параметрам :

Чтобы загрузить библиотеку/артефакт в локальный репозиторий .m2/repository можно использовать плагин dependency с целью (goal) get следующим образом :

Примечание : в среде разработки Eclipse библиотеку JFreeChart можно установить как «User Library» и подключать к проектам.

Архитектура библиотеки JFreeChart

На следующем рисунке представлена схема взаимодействия различных классов библиотеки JFreeChart.

Подключение библиотеки JFreeChart к приложению

Архитектура прикладного уровня, представленная на следующем рисунке, объясняет, как библиотеку JFreeChart можно подключить к Java приложению.

Программа читает данные на основе которых с использованием JFreeChart API формирует требуемое изображение, которое можно будет либо отобразить в интерфейсе приложения (например Swing приложение), либо сформировать изображение типа JPEG или PNG.

Настройка диаграмм JFreeChart

Структура библиотеки JFreeChart создана таким образом, чтобы можно было статически и динамически настраивать общий вид диаграммы и графическое представление данных. Подробное описание свойств диаграммы JFreeChart представлено здесь. Примеры использования JFreeChart в сервлетах наглядно демонстрируют возможности изменения внешнего вида диаграммы изменением отдельных свойств.

Примеры построения диаграмм JFreeChart

Рассмотрим примеры создания 3-х графических изображений JFreeChart : круговая диаграмма (PieChartDemo.java), гистограмма (BarChartDemo.java) и временная диаграмма (TimeSeriesChartDemo.java). Для этого нам необходимо :

  1. Подготовить наборы данных для построения графиков.
  2. Создать графические объекты типа JFreeChart.
  3. Отобразить графические объекты JFreeChart на экране.

Наборы данных для построения графиков

Основой наборов данных для создания различных графических изображений типа круговых диаграмм и гистограмм является класс AbstractDataset. Данный класс является родителем DefaultPieDataset, используемый для формирования круговых диаграмм, и DefaultCategoryDataset для построения гистограмм. Для построения временной диаграммы используется набор данных TimeSeries и коллекция TimeSeriesCollection, реализующая интерфейс XYDataset.

Набор данных для круговой диаграммы

Метод createDataset формирует набор данных типа PieDataset для создания круговой диаграммы.

Метод определения значения setValue получает числовое значение value для ключа key, имеющего тип Comparable.

Набор данных для гистограммы

Метод createDataset формирует набор данных типа CategoryDataset для создания гистограммы.

Метод addValue получает в качестве параметров вещественное значение value для строки rowKey и колонки columnKey, имеющих тип Comparable.

Набор данных для графика

Метод createDataset формирует набор данных типа XYDataset для создания линейных XY графиков. Сначала создаются два объекта TimeSeries, которые подготавливают наборы данных. После этого воздаются коллекции TimeSeriesCollection, реализующие интерфейсы XYDataset, IntervalXYDataset, XYDomainInfo, XYRangeInfo.

Создание изображений графических объектов JFreeChart

Для построения различных графиков JFreeChart (гистограммы, круговые диаграммы, линейные графики) используется ChartFactory, содержащий большое количество статических перегруженных методов.

Графическое изображение круговой диаграммы

Для создания круговой диаграммы используем метод createPieChart, которому в качестве параметров передаем наименование заголовка, набор данных, флаги создания легенды, всплывающей подсказки и отображения URL. После этого определяем фон графика, выравнивание, цвет и шрифт заголовка и подзаголовка. При настройке plot’a. определяем цвет и наименования секций, шрифт меток секций.

Подробное описание с примерами настройки интерфейса круговых диаграмм представлено здесь.

Графическое изображение гистограммы

Для создания гистограммы используется метод createBarChart, которому в качестве параметров передаются наименование заголовка, наименование вертикальной оси и набор данных. После этого определяется подзаголовок, фон графика и настраивается plot.

Описание с примерами настройки интерфейса гистограмм представлено здесь.

Временные диаграммы

Для создания временных диаграмм используется метод createTimeSeriesChart, которому в качестве параметров передаются наименования заголовка, осей абсцисс и ординат, набор данных и флаги представления легенды, отображения всплывающей подсказки, отображения адреса URL. Графики будут отображаться на белом фоне. После этого определяются параметры plot’а типа XYPlot.

Временная шкала (ось абсцисс) будет иметь метки в формате «mm.yyyy». Формат временных меток может быть изменен.

Описание с примерами создания и настройки временных диаграмм, а также нанесений аннотаций и маркеров на графики, представлено здесь.

Отображение графических объектов в интерфейсе

Для отображения графических объектов в интерфейсе Swing-приложений создаем объект ChartPanel.

Графические изображения в интерфейсе

Панель представления графических объектов ChartPanel

ChartPanel наследует (extends) свойства Swing GUI класса JPanel и предназначена для отображения графических объектов JFreeChart. Класс содержит несколько конструкторов, которые в качестве основного параметра получают объект JFreeChart.

Создаваемое графическое изображение отображается на панели и автоматически перерисовывается при получении соответствующих уведомлений.

Ссылка на основную публикацию
Adblock
detector