Документация

Сгенерируйте простые анимации

Каждый примитив библиотеки plot знает, сколько спецификаций типа “располагается”, это должно ожидать. Например, одномерный функциональный график в 2D такой как

plot::Function2d(sin(x), x = 0..2*PI):

ожидает одну область значений графика для координаты x, тогда как график двумерной функции в 3D ожидает две области значений графика для координаты y и x:

plot::Function3d(sin(x^2 + y^2), x = 0..2, y = 0..2):

Контурный график в 2D ожидает 2 области значений для координаты y и x:

plot::Implicit2d(x^2 + y^2 - 1, x = -2..2, y = - 2..2):

Контурный график в 3D ожидает 3 области значений для x, y и координаты z:

plot::Implicit3d(x^2 + y^2 + z^2 - 1, x = -2..2,
                 y = - 2..2, z = - 2..2):

Строка в 2D не ожидает спецификации области значений:

plot::Line2d([0, 0], [1, 1]):

Таким образом очень легко действительно создать анимированные объекты: Только передайте “избыточное” уравнение области значений a = amin..amax генерирующемуся вызову примитива. Будут анимированы все другие записи и атрибуты примитива, которые являются символьными выражениями параметра анимации. В следующем вызове оба выражение function, а также область значений x функционального графика зависит от параметра анимации. Кроме того, области значений, задающие ширину и высоту прямоугольника, а также конечную точку строки, зависят от него:

plot(
 plot::Function2d(a*sin(x), x = 0..a*PI, a = 0.5..1),
 plot::Rectangle(0..a*PI, 0..a, a = 0.5..1,
                 LineColor = RGB::Black),
 plot::Line2d([0, 0], [PI*a, a], a = 0.5 ..1,
                   LineColor = RGB::Black)
)

Дополнительные спецификации области значений могут войти через графические атрибуты. Вот анимированная дуга, радиус которой и “угловая область значений” зависит от параметра анимации:

plot(plot::Arc2d(1 + a, [0, 0], AngleRange = 0..a*PI, a = 0..1)):

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

В следующих примерах мы хотим задать статический полукруг, с помощью plot::Arc2d с AngleRange = 0..PI. Однако AngleRange записан неправильно. График создается. Это - анимированный полный круг с параметром анимации AngelRange!

plot(plot::Arc2d(1, [0, 0], AngelRange = 0..PI)):

Параметр анимации может быть любым символьным параметром (identifier или indexed identifier), который отличается от символов, используемых для обязательных спецификаций области значений (таких как имена независимых переменных в функциональных графиках). Параметр должен также отличаться от любого из защищенных имен атрибутов графика.

В следующем примере, различные имена a, b используется для параметров анимации двух функций:

plot(plot::Function2d(4*a*x, x = 0..1, a = 0..1),
     plot::Function2d(b*x^2, x = 0..1, b = 1..4)):

Параметр анимации является глобальным символьным именем. Это может использоваться в качестве глобальной переменной в процедурах, задающих графический объект. Следующий пример показывает 3D график двумерной функции, которая задана процедурой с помощью глобально заданного параметра анимации. Далее, mycolor fill color function задан, который изменяет цвет в ходе анимации. Это могло использовать параметр анимации в качестве глобального параметра, как функциональный f делает. Также параметр анимации может быть объявлен как дополнительный входной параметр. Обратитесь к странице справки FillColorFunction, чтобы узнать, сколько введенных параметров функция цвета заливки ожидает и какой из входных параметров питается параметром анимации. Каждый находит, что для plot::Function3d, функция цвета заливки вызвана с координатами x, y, z точек на графике. Следующий входной параметр (4-й аргумент mycolor) является параметром анимации:

f := (x, y) -> 4 - (x - a)^2 - (y - a)^2:
mycolor := proc(x, y, z, a) 
  local t;
  begin
     t := sqrt((x - a)^2 + (y - a)^2):
     if t < 0.1 then 
          return(RGB::Red)
     elif t < 0.4 then
          return(RGB::Orange)
     elif t < 0.7 then
          return(RGB::Green)
     else return(RGB::Blue)
     end_if;
end:
plot(plot::Function3d(f, x = -1..1, y = -1..1, a = -1..1, 
                      FillColorFunction = mycolor)):

Проигрывайте анимации

Когда анимированный график создается в блокноте MuPAD^®, первый кадр анимации появляется как статическое изображение ниже входной области. Чтобы запустить анимацию, дважды щелкают по графику. Значок для запуска анимации появится (убедитесь, что элемент ‘Панель Анимации’ меню 'View' включен):

Можно также использовать ползунок, чтобы анимировать изображение “вручную”. Также меню 'Animation' обеспечивает элемент для запуска анимации.

Количество кадров и области значений времени

По умолчанию анимация состоит из 50 различных кадров. Номер кадров может быть определен, чтобы быть любым положительным числом n путем определения атрибута Frames = n. Этот атрибут может быть установлен в генерирующемся вызове анимированных примитивов, или в некотором более высоком узле графического дерева. В последнем случае этот атрибут наследован ко всем примитивам, которые существуют ниже узла. С a = amin..amax, Frames = n, i-th кадр состоит из снимка состояния примитива с

Увеличение числа кадров не означает, что анимация запускается дольше; средство отображения не работает с постоянным числом кадров в секунду, но обрабатывает все кадры в фиксированном временном интервале.

В фоновом режиме существуют “часы реального времени”, используемые, чтобы синхронизировать анимацию различных анимированных объектов. Анимация имеет область значений времени, измеренную этими часами. Область значений времени установлена атрибутами TimeBegin = t0, TimeEnd = t1 или, эквивалентно, TimeRange = t0..t1, где t0, t1 является действительными численными значениями, представляющими физические времена в секундах. Они приписывают, может быть установлен в генерирующемся вызове анимированных примитивов, или в некотором более высоком узле графического дерева. В последнем случае эти атрибуты наследованы всеми примитивами, которые существуют ниже узла.

Абсолютное значение t0 не важно, если все анимированные объекты совместно используют ту же область значений времени. Только разница во времени вопросы t1 - t0. Это - (приближение) физическое время в секундах, которые продлится анимация.

Вот простой пример:

plot(plot::Point2d([a, sin(a)], a = 0..2*PI, 
                   Frames = 100, TimeRange = 0..5)):

Точка будет анимирована в течение приблизительно 5 физических секунд, в которые она проходит один период графика синуса. Каждый кадр отображен в течение приблизительно 0,05 секунд. После увеличения числа кадров фактором 2, каждый кадр отображен в течение приблизительно 0,025 секунд, делая анимацию несколько более сглаженной:

plot(plot::Point2d([a, sin(a)], a = 0..2*PI, 
                   Frames = 200, TimeRange = 0..5)):

Обратите внимание на то, что человеческий глаз не может различать различные кадры, если они изменяются с уровнем больше чем 25 кадров в секунду. Таким образом количество кадров набор n для анимации должно удовлетворить

Следовательно, со временем по умолчанию располагаются TimeBegin = t0 = 0, TimeEnd = t1 = 10 (секунды), это не целесообразно задавать Frames = n с n > 250. Если более высокий номер кадра требуется, чтобы получать достаточное разрешение анимированного объекта, нужно увеличить время для анимации достаточно высоким значением TimeEnd.

Что может быть анимировано?

Мы можем рассматривать графический примитив как набор атрибутов графика. (Действительно, также выражение function sin(x) в plot::Function2d(sin(x), x = 0..2*PI) внутренне понято в атрибуте Function = sin(x).) Так, вопрос:

  “Какие атрибуты могут быть анимированы?”

Ответ: “Почти любой атрибут может быть анимирован!” Вместо того, чтобы перечислить атрибуты, которые позволяют анимацию, намного легче охарактеризовать атрибуты, которые не могут быть анимированы:

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

Усовершенствованные анимации: модель синхронизации

Как уже объяснено в разделе The Number of Frames и Области значений Времени, существуют “часы реального времени”, запускающиеся в фоновом режиме, который синхронизирует анимацию различных анимированных объектов.

Каждый анимированный объект имеет свою собственную отдельную “оперативную продолжительность жизни”, установленную атрибутами TimeBegin = t0, TimeEnd = t1 или, эквивалентно, TimeRange = t0..t1. Значения t0, t1 представляет секунды, измеренные “часами реального времени”.

В большинстве случаев нет никакой потребности обеспокоиться об определении продолжительности жизни. Если TimeBegin и TimeEnd не заданы, значения по умолчанию, TimeBegin = 0 и TimeEnd = 10 используются, т.е. анимация продлится приблизительно 10 секунд. Эти значения только должны быть изменены

Вот пример для второй ситуации. График состоит из 3 переходящих точек. В течение первых 5 секунд подпрыгивает левая точка, в то время как другие точки остаются в своем исходном положении. Затем все точки остаются статичными в течение 1 секунды. После в общей сложности 6 секунд срединная точка запускает свою анимацию путем подпрыгивания, в то время как левая точка остается статичной в своем конечном положении, и правые точки остается статичным в его исходном положении. После 9 секунд правая точка начинает перемещаться также. Полный отрезок времени для анимации является оболочкой областей значений времени всех анимированных объектов, т.е. 15 секунд в этом примере:

p1 := plot::Point2d(-1, sin(a), a = 0..PI, Color = RGB::Red,
                    PointSize = 5*unit::mm,
                    TimeBegin = 0, TimeEnd = 5):
p2 := plot::Point2d(0, sin(a), a = 0..PI, Color = RGB::Green,
                    PointSize = 5*unit::mm,
                    TimeBegin = 6, TimeEnd = 12):
p3 := plot::Point2d(1, sin(a), a = 0..PI, Color = RGB::Blue,
                    PointSize = 5*unit::mm,
                    TimeBegin = 9, TimeEnd = 15):
plot(p1, p2, p3, PointSize = 3.0*unit::mm, 
     YAxisVisible = FALSE):

Здесь, все точки используют настройки по умолчанию VisibleBeforeBegin = TRUE и VisibleAfterEnd = TRUE, которые делают их видимыми как статические объекты вне области значений времени их анимации. Мы устанавливаем VisibleAfterEnd = FALSE для срединной точки, так, чтобы это исчезло после конца ее анимации. С VisibleBeforeBegin = FALSE правая точка не видима до своих запусков анимации:

p2::VisibleAfterEnd := FALSE:
p3::VisibleBeforeBegin := FALSE:
plot(p1, p2, p3, PointSize = 3.0*unit::mm, 
     YAxisVisible = FALSE):

Мы обобщаем модель синхронизации анимаций:

Кадр покадровыми анимациями

Существуют некоторые специальные атрибуты, такие как VisibleAfter, которые очень полезны, чтобы создать анимации из чисто статических объектов:

Эти атрибуты не должны быть объединены, чтобы задать “диапазон видимости” от t0 до t1. Используйте атрибут VisibleFromTo вместо этого:

Мы продолжаем пример предыдущего раздела, в котором мы задали следующие анимированные точки:

p1 := plot::Point2d(-1, sin(a), a = 0..PI, Color = RGB::Red,
                    PointSize = 5*unit::mm,
                    TimeBegin = 0, TimeEnd = 5):
p2 := plot::Point2d(0, sin(a), a = 0..PI, Color = RGB::Green,
                    PointSize = 5*unit::mm,
                    TimeBegin = 6, TimeEnd = 12):
p3 := plot::Point2d(1, sin(a), a = 0..PI, Color = RGB::Blue,
                    PointSize = 5*unit::mm,
                    TimeBegin = 9, TimeEnd = 15):
p2::VisibleAfterEnd := FALSE:
p3::VisibleBeforeBegin := FALSE:

Мы добавляем дальнейшую точку p4, который не анимирован. Мы делаем его невидимым в начале анимации через атрибут VisibleFromTo. Это сделано видимым после 7 секунд, чтобы исчезнуть снова после 13 секунд:

p4 := plot::Point2d(0.5, 0.5, Color = RGB::Black,
                    PointSize = 5*unit::mm,
                    VisibleFromTo = 7..13):

Запуск анимации определяется p1, который переносит атрибут TimeBegin = 0, конец анимации определяется p3, который установил TimeEnd = 15:

plot(p1, p2, p3, p4, PointSize = 3.0*unit::mm, 
     YAxisVisible = FALSE):

Несмотря на то, что типичная анимация MuPAD сгенерирована объект объектом, каждый анимированный объект, заботящийся о его собственной анимации, мы можем также использовать атрибуты VisibleAfter, VisibleBefore, VisibleFromTo, чтобы создать кадр анимации кадром:

Вот пример. Мы позволяем двум точкам блуждать вдоль графиков синуса и косинусной функции, соответственно. Каждый кадр должен состоять из изображения двух точек. Мы используем plot::Group2d, чтобы задать кадр; группа вперед атрибут VisibleFromTo ко всем его элементам:

for i from 0 to 101 do
    t[i] := i/10;
end_for:
for i from 0 to 100 do
  x := i/100*PI;
  myframe[i] := plot::Group2d(
        plot::Point2d([x, sin(x)], Color = RGB::Red),
        plot::Point2d([x, cos(x)], Color = RGB::Blue),
        VisibleFromTo = t[i]..t[i + 1]);
end_for:
plot(myframe[i] $ i = 0..100, PointSize = 5.0*unit::mm):

Этому “кадру кадром” анимация, конечно, нужно немного больше усилия по кодированию, чем эквивалентная objectwise анимация, где каждая из точек анимирована:

delete i:
plot(plot::Point2d([i/100*PI, sin(i/100*PI)], i = 0..100,
                   Color = RGB::Red),
     plot::Point2d([i/100*PI, cos(i/100*PI)], i = 0..100,
                   Color = RGB::Blue),
     Frames = 101, TimeRange = 0..10,
     PointSize = 5.0*unit::mm):

Существует, однако, специальный вид графика, где “кадр кадром” анимации очень полезен. Обратите внимание на то, что в текущей версии графики, новые объекты графика не могут быть добавлены к сцене, которая уже представляется. Со специальными анимациями “видимости” для статических объектов, однако, можно легко моделировать график, который постепенно растет: Заполните кадры анимации со статическими объектами, которые видимы на ограниченный срок только. Видимость может быть выбрана очень гибко пользователем. Например, статические объекты могут быть сделаны видимыми только для одного кадра (VisibleFromTo) так, чтобы объекты, казалось, перемещались.

В следующем примере мы используем VisibleAfter, чтобы постепенно заполнять график. Мы демонстрируем каустик, сгенерированный солнечным светом в чашке чая. Оправа чашки, рассматриваемой как зеркало, дана функцией, x ∈ [-1, 1] (полукруг). Лучи Sun, параллельные y - ось, отражаются оправой. После отражения в точке (x, f (x)) оправы, луч направляется в направление, если x положителен. Это направляется в направление, если x отрицателен. Развертываясь через зеркало слева направо, входящие лучи, а также отраженные лучи визуализируются как строки. В анимации они становятся видимыми после времени 5 x, где x является координатой точки оправы, в которой отражается луч:

f := x -> -sqrt(1 - x^2):
plot(// The static rim:
     plot::Function2d(f(x), x = -1..1, Color = RGB::Black),
     // The incoming rays:
     plot::Line2d([x, 2], [x, f(x)], VisibleAfter = 5*x
                 ) $ x in [-1 + i/20 $ i = 1..39],
     // The reflected rays leaving to the right:
     plot::Line2d([x, f(x)], 
                  [1, f(x) + (1-x)*(f'(x) - 1/f'(x))/2],
                  Color = RGB::Orange, VisibleAfter = 5*x
                 ) $ x in [-1 + i/20 $ i =  1..19],
     // The reflected rays leaving to the left:
     plot::Line2d([x, f(x)], 
                  [-1, f(x) - (x+1)*(f'(x) - 1/f'(x))/2],
                  Color = RGB::Orange, VisibleAfter = 5*x
                 ) $ x in [-1 + i/20 $ i = 21..39],
     ViewingBox = [-1..1, -1..1]):

Сравните сферическое зеркало с параболическим зеркалом, которое имеет истинный центр:

f := x -> -1 + x^2:
plot(// The static rim:
     plot::Function2d(f(x), x = -1..1, Color = RGB::Black),
     // The incoming rays:
     plot::Line2d([x, 2], [x, f(x)], VisibleAfter = 5*x
                 ) $ x in [-1 + i/20 $ i = 1..39],
     // The reflected rays leaving to the right:
     plot::Line2d([x, f(x)], 
                  [1, f(x) + (1-x)*(f'(x) - 1/f'(x))/2],
                  Color = RGB::Orange, VisibleAfter = 5*x
                 ) $ x in [-1 + i/20 $ i =  1..19],
     // The reflected rays leaving to the left:
     plot::Line2d([x, f(x)], 
                  [-1, f(x) - (x+1)*(f'(x) - 1/f'(x))/2],
                  Color = RGB::Orange, VisibleAfter = 5*x
                 ) $ x in [-1 + i/20 $ i = 21..39],
     ViewingBox = [-1..1, -1..1]):

Примеры

DIGITS := 2:
// the function:
f := x -> cos(x^2):
// the anti-derivative:
F := x -> numeric::int(f(y), y = 0..x):
// the graph of f(x):
g := plot::Function2d(f(x), x = 0..6, Color = RGB::Blue):
// the graph of F(x):
G := plot::Function2d(F(x), x = 0..6, Color = RGB::Black):
// a point moving along the graph of F(x):
p := plot::Point2d([a, F(a)], a = 0..6, Color = RGB::Black):
// hatched region between the origin and the moving point p:
h := plot::Hatch(g, 0, 0 ..a, a = 0..6, Color = RGB::Red):
// the right border line of the hatched region:
l := plot::Line2d([a, 0], [a, f(a)], a = 0..6, 
                  Color = RGB::Red):
// a dashed vertical line from f to F:
L1 := plot::Line2d([a, f(a)], [a, F(a)], a = 0..6, 
                  Color = RGB::Black, LineStyle = Dashed):
// a dashed horizontal line from the y axis to F:
L2 := plot::Line2d([-0.1, F(a)], [a, F(a)], a = 0..6, 
                  Color = RGB::Black, LineStyle = Dashed):
// the current value of F at the moving point p:
t := plot::Text2d(a -> F(a), [-0.2, F(a)], a = 0..6,
                  HorizontalAlignment = Right):
plot(g, G, p, h, l, L1, L2, t, 
     YTicksNumber = None, YTicksAt = [-1, 1]):
delete DIGITS:

c := a -> 1/2 *(1 - 1/sin(PI/2*a)):
mycolor := (u, v, x, y, z) -> [(u - 0.8)/0.4, 0, (1.2 - u)/0.4]:
rectangle2annulus := plot::Surface(
   [c(a) + (u - c(a))*cos(PI*v), (u - c(a))*sin(PI*v), 0],
   u = 0.8..1.2, v = -a..a, a = 1/10^10..1,
   FillColorFunction = mycolor, Mesh = [3, 40], Frames = 40):
plot(rectangle2annulus, Axes = None,
     CameraDirection = [-11, -3, 3]):

annulus2moebius := plot::Surface(
   [((u - 1)*cos(a*v*PI/2) + 1)*cos(PI*v),
    ((u - 1)*cos(a*v*PI/2) + 1)*sin(PI*v),
     (u - 1)*sin(a*v*PI/2)],
   u = 0.8..1.2, v = -1..1, a = 0..1,
   FillColorFunction = mycolor, Mesh = [3, 40], Frames = 20):
plot(annulus2moebius, Axes = None,
     CameraDirection = [-11, -3, 3]):

rectangle2annulus::VisibleFromTo := 0..5:
annulus2moebius::VisibleFromTo := 5..7:
plot(rectangle2annulus, annulus2moebius, Axes = None,
     CameraDirection = [-11, -3, 3]):

ms := 1: m1 := 0.04: m2 := 0.0001:

Y := numeric::odesolve2(numeric::ode2vectorfield(
 {xs''(t) = 
   -m1*(xs(t)-x1(t))/sqrt((xs(t)-x1(t))^2 + (ys(t)-y1(t))^2)^3
   -m2*(xs(t)-x2(t))/sqrt((xs(t)-x2(t))^2 + (ys(t)-y2(t))^2)^3,
  ys''(t) = 
   -m1*(ys(t)-y1(t))/sqrt((xs(t)-x1(t))^2 + (ys(t)-y1(t))^2)^3
   -m2*(ys(t)-y2(t))/sqrt((xs(t)-x2(t))^2 + (ys(t)-y2(t))^2)^3,
  x1''(t) = 
   -ms*(x1(t)-xs(t))/sqrt((x1(t)-xs(t))^2 + (y1(t)-ys(t))^2)^3
   -m2*(x1(t)-x2(t))/sqrt((x1(t)-x2(t))^2 + (y1(t)-y2(t))^2)^3,
  y1''(t) =
   -ms*(y1(t)-ys(t))/sqrt((x1(t)-xs(t))^2 + (y1(t)-ys(t))^2)^3
   -m2*(y1(t)-y2(t))/sqrt((x1(t)-x2(t))^2 + (y1(t)-y2(t))^2)^3,
  x2''(t) = 
   -ms*(x2(t)-xs(t))/sqrt((x2(t)-xs(t))^2 + (y2(t)-ys(t))^2)^3
   -m1*(x2(t)-x1(t))/sqrt((x2(t)-x1(t))^2 + (y2(t)-y1(t))^2)^3,
  y2''(t) = 
   -ms*(y2(t)-ys(t))/sqrt((x2(t)-xs(t))^2 + (y2(t)-ys(t))^2)^3
   -m1*(y2(t)-y1(t))/sqrt((x2(t)-x1(t))^2 + (y2(t)-y1(t))^2)^3,
  xs(0)  = -m1   ,   x1(0)  = ms,     x2(0)  =  0,
  ys(0)  = 0.7*m2,   y1(0)  = 0,      y2(0)  = -0.7*ms,
  xs'(0) = -1.01*m2, x1'(0) = 0,      x2'(0) =  1.01*ms,
  ys'(0) = -0.9*m1,  y1'(0) = 0.9*ms, y2'(0) =  0},
 [xs(t), xs'(t), ys(t), ys'(t),
  x1(t), x1'(t), y1(t), y1'(t), 
  x2(t), x2'(t), y2(t), y2'(t)]
)):

dt := 0.05: imax := 516:
plot(// The sun:
     plot::Point2d(Y(t)[1], Y(t)[3], Color = RGB::Orange,
                   VisibleFromTo = t..t + 0.99*dt,
                   PointSize = 4*unit::mm
                  ) $  t in [i*dt $ i = 0..imax],
     // The giant planet:
     plot::Point2d(Y(t)[5], Y(t)[7], Color = RGB::Red,
                   VisibleFromTo = t..t + 0.99*dt,
                   PointSize = 3*unit::mm 
                  ) $  t in [i*dt $ i = 0..imax],
     // The orbit of the giant planet:
     plot::Line2d([Y(t - dt)[5], Y(t - dt)[7]], 
                  [Y(t)[5], Y(t)[7]], Color = RGB::Red,
                   VisibleAfter = t
                 ) $  t in [i*dt $ i = 1..imax],
     // The small planet:
     plot::Point2d(Y(t)[9], Y(t)[11], Color = RGB::Blue,
                   VisibleFromTo = t..t + 0.99*dt,
                   PointSize = 2*unit::mm
                  ) $  t in [i*dt $ i = 0..imax],
     // The orbit of the small planet:
     plot::Line2d([Y(t - dt)[9], Y(t - dt)[11]], 
                  [Y(t)[9], Y(t)[11]], Color = RGB::Blue,
                  VisibleAfter = t
                 ) $  t in [i*dt $ i = 1..imax]
):