L-System分形

L-System（Lindenmayer system）是一种生成分形图案的方法。与迭代函数系统生成分形依靠数字的迭代不同，L-System依赖的是字符的迭代。字符间也有迭代公式，可以将字符换成某个字符串，随着迭代次数的增加，字符串长度越来越大，而字符串中的每一个字符，都代表着一种对线条的操作，如延伸、旋转等。最后将字符串依次执行一遍，便会得到一张分形图案。

字符的含义：

F/f：向前走固定长度

+：正方向旋转固定角度

-：负方向旋转固定角度

[：将当前的位置存入堆栈

]：从堆栈中取出坐标，修改当前位置

S：出世迭代符号

比如，F+F--F+F这个字符串的结果是

图1

如果迭代规则是 F = F+F--F+F，第一次迭代的结果是

图2

图2的生成过程：相当于当向前走的时候（执行F的时候），不是向前画一条线段，而是向前画一个图1。

我们可以用一个字典来定义一个规则中的所有属性，比如迭代公式、初始符号、初始角度、角度增量等。

生成 6 个分形图案的代码如下，有详细的注释：

# L-System(Lindenmayer system)是一种用字符串替代产生分形图形的算法

from math import sin, cos, pi

from matplotlib import pyplot as pl

from matplotlib import collections

class L_System(object):

    def __init__(self, rule):

        info = rule['S']

        for i in range(rule['iter']): # 迭代次数

            ninfo = [] # 按顺序存放新一轮迭代之后的字符

            for c in info: # info为本轮迭代的输入字符串，遍历它

                if c in rule: # 如果一个字符具有迭代公式

                    ninfo.append(rule[c]) # 根据迭代公式，将此字符换为对应字符串

                else:

                    ninfo.append(c) # 没有迭代公式，保留此字符

            info = "".join(ninfo) # 将字符数组连接为字符串

        self.rule = rule # 保存参数rule

        self.info = info # 迭代过后最终的字符串

    def get_lines(self):

        # 此函数返回一个数组，每个元素是一个元组，包含两个子元组，一个是起始点，一个是终点，表示一条线段。

        d = self.rule['direct'] # 方向初始值

        a = self.rule['angle'] # 每次旋转的角度

        p = (0.0,0.0) # 起点

        l = 1.0 # 运行F时向前走的长度

        lines = [] # 存放结果

        stack = [] # 栈，用于执行[和]

        for c in self.info:

            if c in "Ff": # 根据当前角度，向前画一条线段

                r = d * pi / 180

                t = p[0] + l * cos(r), p[1] + l * sin(r)

                lines.append(((p[0],p[1]),(t[0],t[1])))

                p = t

            elif c == "+": # 旋转角度

                d += a

            elif c == "-": # 旋转角度

                d -= a

            elif c == "[": # 将当前的位置记录到栈中

                stack.append((p,d))

            elif c == "]":

                p, d = stack[-1] # 取出栈中顶层数值，相当于坐标p和方向d回退到了之前某次迭代之后的位置。这说明图形在此位置将要分叉。

                del stack[-1]

        return lines

rules = [ # 定义6个图案的规则

    {

        "F":"F+F--F+F", "S":"F",

        "direct":180,

        "angle":60,

        "iter":5,

        "title":"Koch"

    },

    {

        "X":"X+YF+", "Y":"-FX-Y", "S":"FX",

        "direct":0,

        "angle":90,

        "iter":13,

        "title":"Dragon"

    },

    {

        "f":"F-f-F", "F":"f+F+f", "S":"f",

        "direct":0,

        "angle":60,

        "iter":7,

        "title":"Triangle"

    },

    {

        "X":"F-[[X]+X]+F[+FX]-X", "F":"FF", "S":"X",

        "direct":-45,

        "angle":25,

        "iter":6,

        "title":"Plant"

    },

    {

        "S":"X", "X":"-YF+XFX+FY-", "Y":"+XF-YFY-FX+",

        "direct":0,

        "angle":90,

        "iter":6,

        "title":"Hilbert"

    },

    {

        "S":"L--F--L--F", "L":"+R-F-R+", "R":"-L+F+L-",

        "direct":0,

        "angle":45,

        "iter":10,

        "title":"Sierpinski"

    }

]

def draw(ax, rule, iter=None):

    # 此方法输入一个规则，输出一个figure

    if iter != None:

        rule["iter"] = iter

    lines = L_System(rule).get_lines();

    lineCollections = collections.LineCollection(lines)

    ax.add_collection(lineCollections, autolim=True)

    ax.axis("equal")

    ax.set_axis_off()

    ax.set_xlim(ax.dataLim.xmin, ax.dataLim.xmax)

    ax.invert_yaxis()

fig = pl.figure(figsize=(7,4.5))

fig.patch.set_facecolor("w")

for i in range(len(rules)): # 依次按照规则生成图案

    ax = fig.add_subplot(231 + i)

    draw(ax, rules[i])

fig.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0, hspace=0)

pl.show()