Атрибуты

Пример 1

Как очень простая система, мы рассматриваем следующее правило итерации: “замените каждую линию вперед последовательностью “линия вперед, продвиньтесь без рисования, линия вперед””.:

l := plot::Lsys(0, "F", "F" = "FfF"):

Обратите внимание на то, что мы не предоставляем правило итерации для "f". Это означает, “оставляют f один, не изменяйте его”.

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

l::Generations := 0:
plot(l)

Увеличивая число поколений, мы видим эффект нашего правила преобразования:

l::Generations := 1:
plot(l)

l::Generations := 2:
plot(l)

l::Generations := 3:
plot(l)

Следующий вариант этого простого примера производит приближения для Канторова набора:

l := plot::Lsys(0, "F", "F" = "FfF", "f" = "fff"):
plot(l)

Пример 2

Чтобы получить более интересные примеры, мы включаем вращения в наши правила:

l := plot::Lsys(PI/2, "F-F-F-F", "F" = "F-F+F+FF-F-F+F",
                Generations = 3)

Как вы видите, plot::Lsys обнаружил, что наше правило является правилом итерации. Мы, возможно, использовали этот синтаксис непосредственно при создании объекта. Мы не дали правила черепахи, таким образом, значения по умолчанию используются:

plot(l)

Пример 3

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

peano := plot::Lsys(PI/2, "F", "F" = "F+F-F-F-F+F+F+F-F"):

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

peano::Generations := 1:
plot(peano)

После нескольких итераций линии уже добираются очень друг близко к другу:

peano::Generations := 5:
plot(peano)

Пример 4

Много L-систем содержат различные типы линий: В то время как они чертятся точно то же самое, их правила преобразования отличаются друг от друга. Следующий пример показывает изображение, похожее на Треугольник Серпинского:

l := plot::Lsys(PI/3, "R", "L" = "R+L+R", "R" = "L-R-L",
                         "L" = Line, "R" = Line,
                Generations = 7):
plot(l)

Пример 5

Push и Pop операции могут использоваться, чтобы чертить “руки” в L-системе:

plot(plot::Lsys(23*PI/180, "F", "F" = "FF-[-F+F+F]+[+F-F-F]",
                Generations = 4))

Пример 6

L-системы использовались, чтобы симулировать рост объекта. Мы показываем пример здесь, который использует символы BH, и G изменить цвет линий:

l := plot::Lsys(PI/9, "BL", "L" = "BR[+HL]BR[-GL]+HL", 
                "R" = "RR", "L" = Line, "R" = Line, 
                "B" = RGB::Brown, "H" = RGB::ForestGreen, 
                "G" = RGB::SpringGreen, Generations = 6):
plot(l)

Атрибут Generations может быть анимирован. Таким образом, мы можем на самом деле заставить “объект” “вырасти”:

plot(plot::Lsys(a*PI/45, "BL", "L" = "BR[+HL]BR[-GL]+HL", "R" = "RR",
                "L" = Line, "R" = Line, "B" = RGB::Brown, 
                "H" = RGB::ForestGreen, "G" = RGB::SpringGreen,
                 Generations = a, a = 1 .. 6)):

Пример 7

L-системы могут отобразить несколько популярных фракталов. Одним примером является Снежинка Коха, сгенерированная, заменяя каждую прямую линию на прямую линию, сопровождаемую левым поворотом, другую прямую линию, правый поворот, другую прямую линию, другой левый поворот и линию финишной прямой:

koch := plot::Lsys(PI/3, "F--F--F", "F" = "F+F--F+F"):

Стартовое правило было выбрано, чтобы быть равносторонним треугольником:

koch::Generations := 0:
plot(koch)

Первое поколение выглядит так:

koch::Generations := 1:
plot(koch)

Предел вполне прилично аппроксимирован после пяти поколений:

koch::Generations := 5:
plot(koch)

Наконец, мы используем plot::modify и "StepLength" паз, чтобы показать эти первые две итерации, наложенные друг на друга:

colors := [RGB::Red, RGB::Green, RGB::Blue, RGB::Yellow, RGB::DimGrey]:
plot(plot::modify(koch, Generations = i, 
                  StepLength = 3^(-i), 
                  LineColor = colors[i+1]) $ i = 0..4)

Пример 8

Другим известным примером фрактала, сгенерированного L-системой, является кривая Дракона Хивея. Неофициально, это сгенерировано путем “рисования прямого угла и затем заменяющий каждый прямой угол меньшим прямым углом” (Гарднер). Это использовалось в книге “Парк юрского периода” Майкла Крайтона и таким образом получило другой псевдоним, “фрактал Парка юрского периода”:

plot(plot::Lsys(PI/2, "L", "L" = "L+R+", "R" = "-L-R", 
                "L" = Line, "R" = Line, Generations = 9))

Интересно отметить, что правила итерации этой кривой эквивалентны добавлению зеркальной копии кривой к ее концу:

plot(plot::Lsys(PI/2, "L", "L" = "L+R+", "R" = "-L-R",
                "L" = Line, "R" = Line, Generations = a, 
                a = 1..9))

Пример 9

В то время как L-система предыдущего примера соответствует определению, найденному в литературе, изображения по крайней мере в одном популярном источнике показывают другую систему (в то время как данным определением является то сверху), а именно:

plot(plot::Lsys(PI/4, "X-F-Y", "X" = "X+F+Y", "Y" = "X-F-Y",
                "X" = Line, "Y" = Line, Generations = 9)):

Пример 10

L-система может содержать буквы, которые не предназначены, чтобы показать в итоговой диаграмме, таким образом, они формируют своего рода “маркеры” для последующего iteations. С этой целью можно использовать правило черепахи Noop:

plot(plot::Lsys(PI/12,
                "X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X",
                "X" = "[F+F+F+F[---X-Y]+++++F++++++++F-F-F-F]",
                "Y" = "[F+F+F+F[---Y]+++++F++++++++F-F-F-F]",
                "X" = Noop, "Y" = Noop,
                Generations = 3))

plot(plot::Lsys(PI/2, "FB", 
                "A" = "FBFA+HFA+FB-FA", "B" = "FB+FA-FB-JFBFA",
                "F" = "", "H" = "-", "J" = "+",
                "A" = Noop, "B" = Noop, "H" = Noop, "J" = Noop))

Пример 11

Используя это правило, мы можем использовать следующую формулировку популярной Гильбертовой кривой из-за Кена Филипа:

plot(plot::Lsys(PI/2, "x", "x" = "-yF+xFx+Fy-", "y" = "+xF-yFy-Fx+",
                "x" = Noop, "y" = Noop))

Чтобы анимировать процесс создания Гильбертовой кривой, мы настраиваем длину линий к текущему количеству шагов итерации:

plot(plot::Lsys(PI/2, "x", "x" = "-yF+xFx+Fy-", "y" = "+xF-yFy-Fx+",
                "x" = Noop, "y" = Noop,
                Generations = i, StepLength = 1/(2^i-1),
                i = 1..6, Frames = 6))

Пример 12

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

plot(plot::Lsys(7*PI/15, "F", "F"="F+F--F+F",
                Generations=4))

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

plot(plot::Lsys(7*PI/30,"+++++++++++++++F",
                "F"="F++F----F++F", Generations=4))