Python数学编程 第六章 绘制几何图形与分形 第二节 绘制分形

6.2 绘制分形

q X- a) y/ j! J. D

分形势复杂的几何图案或形状，但却由简单的数学公式所生成。与圆形和矩形等几何图形相比，分形看上去并不规则，也没有明显的模式或描述。但如果仔细观察，你将发现模式的存在，即整个图形有无数个自身的副本构成。由于分形设计平面上的点的相同几何变换的重复引用，因此非常适合使用计算机程序来构建。这一章中，我们将学习如何绘制Barnsley蕨类植物、Sierpinski三角和Manderlbrot集合（后两个出现在编程挑战中），这些都是分形研究领域的常见例子。分形在自然界中比比皆是，常见的例子包括海岸线、树木和雪花。

/ ?9 X! o- s" T. [' G

6.2.1 平面上点的变化

创建分形的基本思想是点的变换。给定x-y平面上的一个点P(x,y)，变幻的一个例子是P(x,y)->Q(x+1, y+1)，这意味着应用变换后，创建好了一个新点Q，它位于P向上和向右各一个单位处。如果以Q点作为起始点，将得到另一个点R，它位于点Q向上和向右各一个单位处。假设起始点P位于（1，1），下图展示了这些点的位置。

S: `8 d$ @/ }* e6 i3 ]

6 _, A1 ]4 Z. r. w$ I @

P、Q、R三个点的位置图

: S* P6 f+ W: E2 u

% L) N3 X F1 g0 U1 z, f

因此，变换是一种描述点在x-y平面上移动的规则，从起始位置开始，每一次迭代使得点移动到新的位置。我们可以把变换想象成点在平面上的轨迹。现在换个思路考虑两个变换规则，每次迭代将从这两个规则中随机选择一个。两个规则如下：

/ v5 o8 }. g$ ?/ C; b% h

规则1：P1(x,y) -> P2(x+1, y-1)

规则2：P1(x,y) -> P2(x+1, y+1)

+ F1 u. @& N/ k8 Z7 X x1 o# y

以P(1, 1)作为起始点，如果我们执行4次迭代，将得到以下一系列的点：

5 l$ n8 M1 P8 t$ S+ \; {

P1(1, 1) -> P2(2, 0) (规则1)

P2(2, 0) -> P3(3, 1) (规则2)

P3(3, 1) -> P4(4, 2) (规则2)

! W8 x9 g% B) Z8 `4 g7 d9 ~5 k

P4(4, 2) -> P5(5, 1) (规则2)

' E+ S' \9 B* D: y6 R( b0 {

...

! f/ N- b+ f& f' P A

两个变换规则是随机选择的，其中每个规则被选择的概率相同。无论选择哪一个规则，点都会右移，因为在两种规则中都会增加x坐标。当点向右移动时，他们会向上或向下移动，从而形成一条Z字路径。以下程序绘制了在指定的迭代次数内进行上述转换规则之一时点的路径：

" ]% j+ i. O3 _; u+ { Example of selecting a transformation from two equally probable transformations ) ^8 `8 d# ]2 O2 Q" y3 f import matplotlib.pyplot as plt import random def transformation_1(p): , x3 u* {4 m) s7 z x = p[0] $ f: i, M4 F- i/ M y = p[1] return x + 1, y - 1 / g: V6 a. ?8 e. v def transformation_2(p): x = p[0] y = p[1] & m0 @( e3 Y# m return x + 1, y + 1 ' X: k6 o! r7 W- a def transform(p): # List of transformation functions transformations = [transformation_1, transformation_2] 6 o5 v; c, g/ v4 i0 W( p # pick a random transformation function and call it % k9 j f: ], d9 r t = random.choice(transformations) / R9 _1 p! q0 V) @ x, y = t(p) return x, y . L% w; F, X- T3 R$ ^9 U7 |9 C def build_trajectory(p, n): 1 \: ]! N3 o4 `; e) v x = [p[0]] y = [p[1]] for i in range(n): p = transform(p) ; K. x2 g( I5 F1 D [2 q x.append(p[0]) y.append(p[1]) return x, y if __name__ == __main__: # Initial point p = (1,1) n = int(input(Enter the number of iterations: )) x , y = build_trajectory(p, n) * m4 R- V5 V) S- ?; O # PLot / [0 s+ }! w w) c9 g( v: z plt.plot(x, y) plt.xlabel(X) plt.ylabel(Y) plt.show()

我们定义了两个函数transformation_1()和transformation_2()，分别对应于之前的两种变换规则，在transform()函数中，我们创建了一个包含这两个函数名字的列表，然后使用random.choice()函数从该列表中选择去哦中一个进行变换。现在假设我们选择了其中一个变换，蒋点P作为输入参数调用该变换函数，然后分别使用x，y来存储变换后的坐标并且返回它们。

从列表中随机选择一个元素

, R" g& j3 x5 P

我们在第一个分形程序中看到的random.choice()函数可以用来从列表中随机选择一个元素，每一个元素被选中的概率相同，下面是一个例子：

import random >>> l = [1,2,3] 9 \$ l4 J/ L, s) T1 v0 @. ~) D! C >>> random.choice(l) 1 >>> random.choice(l) 2 R* t3 ?8 m9 H, L9 l. W2 q 3 >>> random.choice(l) " W; X$ n- `9 i! Q/ s) X3 @6 M0 p. Y 3 9 g* o. ]/ l& a >>> random.choice(l) 1 % H9 `# e7 ~% j% H8 k: J >>> random.choice(l) + l2 }( }( r* n6 D' C# } 1

这个函数也适用于元组和字符串。在后一种情形中，函数从字符串中随即返回一个字符。

6 i8 d. u {4 b- P7 l

当运行程序，他首先会询问迭代次数n，即应用变化的次数。然后调用build_trajectory()函数，该函数的输入参数为迭代次数n和起始点坐标p，此处设置初始点坐标为（1，1）。build_trajectory()函数重复调用n次transform()函数，并使用两个列表x和y分别存储变换后的x和y坐标。最后使用这两个列表来绘制图形。

下面两张图分别显示了100次和10000次迭代的点的轨迹图，这两幅图中的Z字形运动都很明显，这种Z字形路径通常被称为一条线上的随机游走。

4 x: d. ~) h5 b( w

迭代100次的Z字路径

. K# H: V6 r6 W9 C; R J

0 R* J( m2 ?" x. G# u X% Q! g! ?

迭代10000次的Z字路径

这个例子展示了创建分形的基本思想，即从一个点开始并对其重复应用某种变换。接下来，我们将看到一个用相同想法绘制Barnsley蕨类植物的例子。

! f1 h! z( w0 F+ R# z; P6 Q( M

6.2.2 绘制Barnsley蕨类植物

" Q# M$ m; I1 w& R$ ~/ B u) l

英国数学家Michael Barnsley描述了如何对一个点进行重复的简单变换，从而创建蕨类植物的结构（如下图）。

z0 I% K/ i6 L, A6 b6 L1 M

蕨类植物

; E( `8 ]0 s) j! N% j# J5 i- ^& k

他提出了以下步骤来创建类似于蕨类植物的结构，以（0，0）为初始点，按事先分配的概率随机选择下述某种变换。

（1）变换1（概率为0.85）：

( b$ w# o$ q1 @0 p- s: d8 B

1 I/ k. Q, P2 U! }& T

（2）变换2（概率为0.07）：

* y* {: D. d$ W

（3）变换3（概率为0.07）：

% p; g" \% y/ t [: U

（4）变换4（概率为0.01）：

9 D# c% V: ~$ [9 A, H" J6 y3 X

上述每一个变换对应于蕨类植物的一部分。第一个变换被选中的概率最大，因此被执行的次数最多，从而产生了蕨类植物的茎和底部的叶子。第二个和第三个变换分别对应于左边和右边底部的叶子，第四个变换绘制了蕨类植物的茎。

/ H% A, Q9 l2 @0 g! @; `' }

这是一个非均匀概率选择的例子，我们在第五章中已经学习过，以下程序为指定的点数绘制Barnsley蕨类植物。

Draw a Barnsley Fern 7 H! r6 ^2 Q- S8 C import random 0 Z& {, J5 F% O* s9 U# o. Z/ `* o import matplotlib.pyplot as plt ) w' }4 T. j# v" u( o! C1 {- { def transformation_1(p): . u; E: o4 L$ y: c x = p[0] ; l8 d! o- V$ O# Q( o- [ y = p[1] 2 n7 E O9 g5 X- M5 J5 N x1 = 0.85*x + 0.04*y / R3 I u) Z0 s( B6 G \ y1 = -0.04*y + 0.85*y + 1.6 6 r+ h& g" z) P9 W return x1, y1 $ b5 I8 V1 u2 D' [ def transformation_2(p): 9 J/ K7 ^3 c8 i& N0 J x = p[0] 5 j4 g: l1 V' f0 Q$ q) a y = p[1] 6 F! L4 }7 _/ c" ? x1 = 0.2*x - 0.26*y y1 = 0.23*y + 0.22*y + 1.6 , [2 \# g4 b- t return x1, y1 ( S5 L# `& [+ A4 ^9 Y8 M def transformation_3(p): 6 ~6 O! k: E) v, L2 o; G2 D x = p[0] 2 z _' s- i/ z# G) P1 R; ?* w* H( @ y = p[1] x1 = -0.15*x + 0.28*y y1 = 0.26*y + 0.24*y + 0.44 return x1, y1 % i' h, V' ~4 g9 ?% t p def transformation_4(p): x = p[0] ' Y* u( K' D2 R y = p[1] x1 = 0 y1 = 0.16*y . R# r. N) e& }2 G return x1, y1 * |* r# t; ?) \1 J9 q. j9 @, F def get_index(probability): r = random.random() 2 [( B! x. F! P( s' w1 ? c_probability = 0 sum_probability = [] 6 _) X, S& @1 c; B2 { for p in probability: c_probability += p # {# ]' e6 q, c6 M: F sum_probability.append(c_probability) - g# ~/ }- v8 j( l for item, sp in enumerate(sum_probability): 8 d8 X7 L) W- e# ~! T) L, X: W if r < sp: return item 9 P8 E2 L3 k4 w0 T8 X9 Y, k return len(probability) - 1 $ [8 G1 k u- ^! Q! z" `# m0 }# o def transform(p): # List of transformation functions transformation = [transformation_1, transformation_2, transformation_3, transformation_4] probability = [0.85, 0.07, 0.07, 0.01] # Pick a random transformation function and call it ' r$ G- M$ {" [ r( o; E tindex = get_index(probability) t = transformation[tindex] x, y = t(p) 4 q+ s9 H0 F( g' |4 s. V) N2 H5 R return x, y def draw_fern(n): # We start with (0,0) `3 h) e. J1 E; m( }: C3 f& c x = [0] 7 t% q { r) `: z3 D& A y = [0] 1 d6 B5 w# N5 n x1, y1 = 0, 0 for i in range(n): ' q$ Q$ p" o$ }' F x1, y1 = transform((x1, y1)) x.append(x1) & P' B$ n7 g* ?) R, \" ] y.append(y1) return x, y if __name__ == __main__: 4 c4 `- j# z* {% H" v9 `3 h n = int(input(Enter the number of points in the Ferns: )) 3 k1 |, c- R+ C! m x, y = draw_fern(n) / z9 x% E5 O% y9 z/ H$ F+ J plt.plot(x, y, o) plt.title(Fern with {0} points.format(n)) plt.show() 6 K/ J, c% O- w! C. Z

运行此程序，他首先询问蕨类植物图中指定的点数，然后开始绘制该图。下面两张图分别展示了具有1000个点和10000个点的蕨类植物图。

: ]& @/ c0 X* Q9 W! y6 k. H: S

制定了1000个点的蕨类植物叶片

% [8 ?( a: A% J$ x9 D# v

指定了10000个点的蕨类植物叶片

+ N3 F; q. W4 U: M3 u; D" w; ^

, L, Z: l. C; M- G' i

这4个变换规则分别在transformation_1()，transformation_2()，transformation_3()，transformation_4()函数中定义。get_index()函数返回按照给定概率下的一种随机变化的索引值，这个概率我们之前已经讲过了，不清楚的可以返回去在第五章非均匀概率那里再次学习。返回索引之后即可选择某一个具体的变换来应用。

! g8 {/ `5 a2 Z* u

初始点（0，0）变换的次数即为程序输入中指定的蕨类植物点的个数。

( @3 m6 u. Z( R! P+ e' W! U & P% g3 A) m8 K' o % J5 L) E5 }) @$ V; W. U - ]2 m" l" |( \5 u