Python自学系列--使用LS文法绘制分形图形

最新推荐文章于 2024-03-29 21:15:00 发布
最新推荐文章于 2024-03-29 21:15:00 发布
阅读量1.8k 收藏 10
点赞数 3
分类专栏： Others 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39430411/article/details/104335114
版权

一、前言

       作为一名python语言的初学者，在看其官方文档时，看到标准库里有一个海龟画图，感觉挺好玩的。于是研究了一下，便依葫芦画瓢，自己画一个简单的棒棒糖 🍭（画了哄小孩子的）。只是这个海龟画图好象有些眼熟，努力回忆，想起自己好几年前看过一本《分形算法与程序设计–Java实现》（2003年出版的，孙博文编著），里面介绍了一种LS文法，和这很相似。那本书比较老，因此里面的代码也是比较古老的，还是使用的applet。那本书里介绍了几种分形算法，其中LS文法与海龟绘图原理一样。既然要自学python，那就要编码实践，所以打算使用python的海龟绘图来实现这个LS文法绘制。

二、LS文法

       文法构图算法是仿照语言学中的语法生成方法来构造图形的一种算法。

       美国著名语言学家乔姆斯基(N.Chomsky)在20世纪50年代给出了递归生成语法的方法：指定一个或者几个初始字母和一组“生成规则”，将生成规则反复作用到初始字母和新生成的字母上，产生出整个语言。这就是由“生成语法”定义的形式语言，例如：

       字母表： L，R
       生成规则： L -> R，R -> LR
       初始字母： R

       则有 R -> LR -> RLR -> LRRLR -> RLRLRRLR -> LRRLRRLRLRRLR ->…

       LS文法于1984年由A.R.Smith首次引入到计算机图形学领域。

       在二维平面上，LS文法的图形生成过程，类似于海龟在沙滩上行走。海龟行走的每一时刻的状态定义为当前位置矢量T与前进方向角δ的集合(T，δ)，则二维LS文法字母表的绘图规则如下：

  • F：在当前方向前进一步，并画线
  • f ：在当前方向前进一步，不画线
  • +：逆时针旋转一个角度δ
  • -：顺时针旋转一个角度δ
  • [ ：将当前信息压栈
  • ] ：将[时刻的信息出栈

       举一个拟在后面实现的例子：Koch曲线。它的LS文法如下：

  • ω：F
  • δ：60°
  • P：F -> F+F–F+F

则有：

  • 步骤0：F
  • 步骤1：F+F–F+F
  • 步骤2：F+F–F+F+F+F–F+F–F+F–F+F+F+F–F+F
  • 步骤3：F+F–F+F+F+F–F+F–F+F–F+F+F+F–F+F+F+F–F+F+F+F–F+F–F+F–F+F+F+F–F+F–F+F–F+F+F+F–F+F–F+F–F+F+F+F–F+F+F+F–F+F+F+F–F+F–F+F–F+F+F+F–F+F

三、python下简单实现

       python实现需要利用海龟绘图这个模块。因为LS文法可以画很多图形，所以为了复用，先写LS方法模块。

       打开IDLE，新建一个文件，输入如下代码：

# LS文法生成图形的库(公用)
from turtle import *


# 初始化原点及画笔
def init(x,y,_speed):
    ht()
    up()
    speed(_speed)
    setx(x)
    sety(y)
    color('red')
    down()


# 在当前方向向前走一步,并画线
def drawF(step):
    forward(step)


# 在当前方向向前走一步,不画线
def drawf(step):
    up()
    forward(step)
    down()


# 反时针旋转a度
def drawPlus(a):
    left(a)


# 顺时针旋转a度
def drawMinus(a):
    right(a)


# 压栈
def push():
    pass


# 出栈
def pop():
    pass


def draw(ls,step,angel,x,y,_speed):
    init(x,y,_speed)
    for c in ls:
        if c == 'F':
            drawF(step)
        elif c == 'f':
            drawf(step)
        elif c == '+':
            drawPlus(angel)
        elif c == '-':
            drawMinus(angel)
        elif c == '[':
            push()
        elif c == ']':
            pop()
        else:
            print("invalid char:",c)
    done()


# LS文案生成，返回一个list
# 参数分别为初始条件(list)，规则(字典)和迭代次数
def getLs(origin,rule,n):
    L = []
    for key in origin:
        if key in rule:
            des = rule[key]
            L += list(des)
        else:
            L.append(key)
    if n == 1:
        return L
    else:
        return getLs(L,rule,n-1)


Draw,GetLs = (draw,getLs)

       这其中getLs是递归调用来生成LS文法字符串，压栈和出栈操作现在还暂缺。第一现阶段没有用到[和]，第二作为一个初学者，没有反复尝试、实际运行和来回修改我也没办法凭空写出相应的代码。

       将文件保存为drawLs.py，然后再新建一个文件，用来定义Koch曲线的初始规则和条件。

# Koch 曲线LS方法生成
from drawLs import Draw,GetLs


# 定义初始变量
step = 20   # 步长
n = 3        #迭代次数
# 初始条件
origin = 'F'
angel = 60
# 迭代规则
rule = { 'F' : "F+F--F+F" }
# 初始坐标
x = -300
y = 0
# 动画速度
speed = 'normal'


if __name__ == "__main__":
    ls = GetLs(list(origin),rule,n)
    Draw(ls,step,angel,x,y,speed)

       保存为同一目录下的Koch_ls.py。然后点击IDLE菜单上的run，Run Module，一条红色的Koch曲线就慢慢的画出来了。
在这里插入图片描述
       改变初始条件或者初始规则就可以得到不同的图形，有兴趣的读者可以多做尝试。
比如下例条件：

# 初始条件
origin = 'F++F++F'
angel = 60
# 迭代规则
rule = { 'F' : "F+F--F+F" }

画出的图形如下：
在这里插入图片描述

四、增加压栈和出栈操作

       上面的Koch曲线是一条连续的曲线，可以利用一只画笔一气呵成不间断画完。但是如果我们想画一个如下的树，有主干有分叉，一只画笔不间断绘画就无法完成了。
在这里插入图片描述
       这里我们需要在分支的地方保存当前的画笔状态，也就是将画笔入栈。在分支画完以后取出栈中的画笔作为主干画笔再接着画。

       一起来看这个分形树的初始条件和规则：

  • ω：F
  • δ：25°
  • P：F -> F[-F]F[+F]F

       首先需要改写drawLs.py，加入当前画笔和堆栈相关的操作，完成后的代码如下：

# LS文法生成图形的库(公用)
from turtle import *

# 全局变量
stack = []
class Pen:
    current:None


# 初始化原点及画笔
def init(x,y,_speed):
    ht()
    up()
    Pen.current = getpen()
    speed(_speed)
    setx(x)
    sety(y)
    color('red')
    down()


# 在当前方向向前走一步,并画线
def drawF(step):
    Pen.current.forward(step)


# 在当前方向向前走一步,不画线
def drawf(step):
    Pen.current.up()
    Pen.current.forward(step)
    Pen.current.down()


# 反时针旋转a度
def drawPlus(a):
    Pen.current.left(a)


# 顺时针旋转a度
def drawMinus(a):
    Pen.current.right(a)


# 压栈
def push():
    pen = Pen.current.clone()
    stack.append(pen)


# 出栈
def pop():
    Pen.current = stack.pop()


def draw(ls,step,angel,x,y,_speed):
    init(x,y,_speed)
    for c in ls:
        if c == 'F':
            drawF(step)
        elif c == 'f':
            drawf(step)
        elif c == '+':
            drawPlus(angel)
        elif c == '-':
            drawMinus(angel)
        elif c == '[':
            push()
        elif c == ']':
            pop()
        else:
            print("invalid char:",c)
    done()


# LS文案生成，返回一个list
# 参数分别为初始条件(list)，规则(字典)和迭代次数
def getLs(origin,rule,n):
    L = []
    for key in origin:
        if key in rule:
            des = rule[key]
            L += list(des)
        else:
            L.append(key)
    if n == 1:
        return L
    else:
        return getLs(L,rule,n-1)


Draw,GetLs = (draw,getLs)

       可以看到，改写后对外的接口没有变化，运行Koch_ls.py，你仍然会得到相同的结果。代码中使用了一个全局变量来记录当前画笔，压栈时就克隆当前画笔然后保存，出栈时就将弹出的画笔作为当前画笔。作为一个python初学者，我在全局变量引用这里也耽误了一点时间（因为我也没有仔细看过文档）。全局变量在函数中除非声明为global，否则只能读取而不能直接赋值改变（可以间接改变）。直接给全局变量赋值相当于创建了一个同名的局部变量，这一点和其它语言不相同，还是有些不习惯。

       接着实现上面的分形树，再新建一个Tree_ls.py，代码如下：

# 分形树实现
from drawLs import Draw,GetLs

# 定义初始变量
step = 10  # 步长
n = 3       #迭代次数
# 初始条件
origin = 'F'
angel = 25
# 迭代规则
rule = { 'F' : "F[-F]F[+F]F" }
# 初始坐标
x = 0
y = 0
# 动画速度
speed = 'fast'


if __name__ == "__main__":
    ls = GetLs(list(origin),rule,n)
    Draw(ls,step,angel,x,y,speed)

画出的树如下图：
在这里插入图片描述
       可以看到，我们的树变成横向生长了，这是因为我们的画笔（海龟）的初始方向是水平的，接下来我们对它进行完善。

五、进一步完善

计划完善的地方有：

  • 可以提供初始方向（角度）
  • 可以增加渲染速度

我们给drawLs.py中的draw()方法增加两个参数，head和_tracer，分别代表初始方向和渲染的条件。相应的也要修改该文件的其它部分代码，修改完成后代码如下：

# LS文法生成图形的库(公用)
from turtle import *

# 全局变量
stack = []
class Pen:
    current:None


# 初始化原点及画笔
def init(x,y,_speed,head,_tracer=None):
    ht()
    up()
    Pen.current = getpen()
    speed(_speed)
    if _tracer:
        tracer(_tracer,0)
    setx(x)
    sety(y)
    color('red')
    seth(head)
    down()


# 在当前方向向前走一步,并画线
def drawF(step):
    Pen.current.forward(step)


# 在当前方向向前走一步,不画线
def drawf(step):
    Pen.current.up()
    Pen.current.forward(step)
    Pen.current.down()


# 反时针旋转a度
def drawPlus(a):
    Pen.current.left(a)


# 顺时针旋转a度
def drawMinus(a):
    Pen.current.right(a)


# 压栈
def push():
    pen = Pen.current.clone()
    stack.append(pen)


# 出栈
def pop():
    Pen.current = stack.pop()


def draw(ls,step,angel,x,y,_speed,head,_tracer):
    init(x,y,_speed,head,_tracer)
    for c in ls:
        if c == 'F':
            drawF(step)
        elif c == 'f':
            drawf(step)
        elif c == '+':
            drawPlus(angel)
        elif c == '-':
            drawMinus(angel)
        elif c == '[':
            push()
        elif c == ']':
            pop()
        else:
            print("invalid char:",c)
    if _tracer:
        update()
    done()


# LS文案生成，返回一个list
# 参数分别为初始条件(list)，规则(字典)和迭代次数
def getLs(origin,rule,n):
    L = []
    for key in origin:
        if key in rule:
            des = rule[key]
            L += list(des)
        else:
            L.append(key)
    if n == 1:
        return L
    else:
        return getLs(L,rule,n-1)


Draw,GetLs = (draw,getLs)

我们在Tree_ls.py中也增加这两个初始条件：

# 分形树实现
from drawLs import Draw,GetLs

# 定义初始变量
step = 6  # 步长
n = 4       #迭代次数
# 初始条件
origin = 'F'
angel = 25
# 迭代规则
rule = { 'F' : "F[-F]F[+F]F" }
# 初始坐标
x = 0
y = -200
# 动画速度
speed = 'fast'
# 初始角度
head = 90
# 渲染速度
tracer = 5


if __name__ == "__main__":
    ls = GetLs(list(origin),rule,n)
    Draw(ls,step,angel,x,y,speed,head,tracer)

我们将初始角度设定为正北方，并且加快了渲染速度，生成图形如下：
在这里插入图片描述
       然而这里面也遇到了一个坑，如果你使用了trace()方法来设定渲染条件，那么只有符合条件的绘制渲染出来了，未符合条件的绘制并没有显示。作为一个初学者，我也是有些蒙圈😂😂😂。后来仔细看了一下文档，看到介绍有update()方法，试了下，果然如此🤝🤝🤝。它的作用是在你设置渲染条件的情况下强制刷新一下，这样所有的部分都会显示出来。

       同样，我们修改Koch_ls.py的代码来增加这两个初始条件:

# Koch 曲线LS方法生成
from drawLs import Draw,GetLs


# 定义初始变量
step = 10   # 步长
n = 4        #迭代次数
# 初始条件
origin = 'F++F++F'
angel = 60
# 迭代规则
rule = { 'F' : "F+F--F+F" }
# 初始坐标
x = -300
y = -350
# 动画速度
speed = 'fast'
# 初始角度
head = 0
# 渲染速度
tracer = 5

if __name__ == "__main__":
    ls = GetLs(list(origin),rule,n)
    Draw(ls,step,angel,x,y,speed,head,tracer)

六、绘制其它图形

       让我们任意改变一下分形树的规则，将 F -> F[-F]F[+F]F 后面加一个F改成 F -> F[-F]F[+F]FF。生成的图形如下：
在这里插入图片描述
       接着上面的修改，将初始条件变成origin = 'F[+F][-F]F'，生成的图形如下图：
在这里插入图片描述
       柳枝的绘制：

  • ω：F
  • δ：20°
  • P：F -> F[-F]F[+F]-F
    在这里插入图片描述
           手帕的绘制：
# 定义初始变量
step = 20 # 步长
n = 3       #迭代次数
# 初始条件
origin = 'F+F+F+F'
angel = 90
# 迭代规则
rule = { 'F' : "F[F]+F-F[++F]-F+F" }
# 初始坐标
x = 200
y = -200
# 动画速度
speed = 'fast'
# 初始角度
head = 90
# 渲染速度
tracer = 250

在这里插入图片描述

七、总结

       LS文法绘制分形图形是先多次迭代后生成图形的路径，然后用画笔分别描绘出来。这里只学习了LS单规则文法，还有多规则文法。多规则文法简单的讲就是增加规则表中的字母种类，有的只作替换（比如X），有的既作替换，也做绘制（比如F）。有兴趣的读者可以自己阅读一下相关书籍。

       这里的LS文法路径是预先生成好并保存在list中的长串字符，当规则复杂，迭代次数很多时并不是很高效。下一步看能否用一个生成器代替。

       欢迎大家指出错误或者提出改进意见。

AiMateZero
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
利用python画分形图_用python绘制美丽的分形图
weixin_39983427的博客
11-27 2253
1. 曼德勃罗集import numpy as npimport pylab as plimport timefrom matplotlib import cmdef iter_point(c): z = c for i in xrange(1, 100): # 最多迭代100次 if abs(z)>2: break # 半径大于2则认为逃逸 z = ...
分形学习之LS文法构图
For the glory of Lion
10-04 3619
如果昨天的递归分形算法画出的图案好象不那么有技术含量,那么今天的LS文法构图算法就很有档次了!CQ今天弄出了这个东西后也是非常激动啊!   好东西啊!要和大家分享!哈哈! 首先来介绍一下LS文法,这是在美国生物学家Axxx Lxxx (名字太长,不好记!不过感谢他的发明!哈哈!) 发明的一种文法描述方法: graftal上逐渐发展起来的形式语言的一个重要分支.后来人们称之为L-system
用Python标准GUI库Tkinter绘制分形图
最新发布
cnds123的专栏
03-29 639
使用Python的标准GUI库Tkinter实现曼德勃罗集、科赫曲线、谢尔宾斯基三角。
LS文法绘图系统
codexy的专栏
05-15 724
//ls.h#ifndef __LS_H__#define __LS_H__#include #include #include #include #ifndef PI#define PI 3.1415926f#endifusing namespace std;/**********************************************
用Python绘制一套“会跳舞”的动态图形
算法channel
10-15 568
作者：Costas Andreou机器之心编译参与：Jamin、张倩【我原创的Python绘图专题，今天没改好，我改好后尽快发出来】看这优美的舞姿数据暴增的年代，数据科学家、分析师在被要...
基于Python的几何图形绘图软件设计 文档+项目源码+使用说明书+演示视频
毕业作品网站
05-16 547
目录 1 综述 2 2 算法介绍 2 2.1 绘制线段 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 2.1.1 DDA 算法 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 2.1.2 Bresenham 算法 . . . . . . . . . . . . . . . . . . . . . . . . . .
python使用turtle绘制分形树
01-21
由于分形树具有对称性，自相似性，所以我们可以用递归来完成绘制。只要确定开始树枝长、每层树枝的减短长度和树枝分叉的角度，我们就可以把分形树画出来啦！！ 代码如下： # -*- coding: utf-8 -*- ''' 绘制分形...
python递归函数绘制分形树的方法
09-20
Python递归函数绘制分形树是一种利用编程语言展现分形几何学概念的方式。分形几何是一种研究具有自相似性质的几何形状的数学分支。在本例中，我们将使用Python的turtle模块来创建一个分形树，它由多个相似但大小不一...
js-fractal-compression:使用ES6的玩具分形压缩实现
05-07
使用ES6进行分形图像压缩 有关该理论的简短介绍，请参见 。 分形压缩在1990年代是一件很重要的事情，但是后来业界对它的兴趣减弱了，而诸如JPEG之类的计算密集型格式盛行。 分形压缩是一个非常不对称的过程，其中...
swift-用Swift绘制漂亮的Julia分形图
08-15
在本篇中，我们将深入探讨如何使用Swift来绘制惊艳的Julia集合分形图。Julia集合是一种复杂的数学概念，它源于复数域中的迭代函数系统，常用于创建视觉上引人入胜的艺术作品。 首先，我们需要了解Julia集合的基本...
分形算法与程序设计PPT
11-21
各种分形算法分析及Python源码。。。。
轻松一下:python(turtle模块)绘制分形图
Morbidmuse的博客
08-12 6242
分形 分形，具有以非整数维形式充填空间的形态特征。通常被定义为“一个粗糙或零碎的几何形状，可以分成数个部分，且每一部分都（至少近似地）是整体缩小后的形状”，即具有自相似的性质。分形（Fractal）一词，是芒德勃罗创造出来的，其原意具有不规则、支离破碎等意义。1973年，芒德勃罗（B.B.Mandelbrot）在法兰西学院讲课时，首次提出了分维和分形的设想。 turtle模块 turtle模块时python自带的一个绘图模块,俗称海龟绘图. 常用方法 方法 描述...
LS文法构图算法(3) Hilbert-Peano曲线
-第二月-的专栏
01-25 5876
        在前面一篇中讲了如何用递归算法来画Hilbert-Peano曲线，这一篇再尝试一下使用LS文法构图算法来构建它。这就要使用多规则的LS文法了，多规则情况下的字母表中，有1个以上的字符，在迭代时更加复杂，每一个字符都要用相应的规则来替换；在绘图时，可以为各种字符规定不同的绘图动作，有的画图，有的可以不画图。        要画Hilbert-Peano这种比较复杂的图，关键就是要
用python动态演示照片立方体_3分钟在线演示用 python 生成分形图片
weixin_39537298的博客
11-29 335
大家好！欢迎来到我们第二期的代码滤镜。不关心实现细节，每天一个炫酷好玩儿的项目演示，激发编程兴趣，扩展技术视野。今天的实验主题是 使用 Python3 生成分形图片。效果图：分形树（Fractal tree)科赫雪花曲线（Koch snowflake)龙形曲线（Dragon curve）视频演示：使用 Python3 生成分形图片https://www.zhihu.com/video/100983...
使用Python创建分形图案
csdn1561168266的博客
04-19 939
分形是无限复杂的模式，在不同的尺度上具有自相似性。例如，一棵树的树干会分裂成更小的树枝。这些树枝又分裂成更小的树枝，以此类推。通过编程的方式生成分形，可以将简单的形状变成复杂的重复图案。本文将探讨如何利用一些简单的几何学基础和编程知识，在Python中建立令人印象深刻的分形图案。分形在数据科学中发挥着重要作用。例如，在分形分析中，对数据集的分形特征进行评估，以帮助理解基础过程的结构。此外，处于分形生成中心的循环算法可以应用于广泛的数据问题，例如从二进制搜索算法到递归神经网络。
LS文法构图算法(4) 分形树
-第二月-的专栏
01-26 6262
        分形树的基本分形元如下图所示，用比较简单的单规则LS文法即可生成。        只是有一个地方要注意，即图形中存在分叉点A和B，从这两点出发绘制完支线后，还要再回到出发点，所以在画到这种点时，要把当前的位置和方向信息入栈保存，支线画完后，再把信息恢复出来，从分支点接着画。        照以下文法可以生成一个最简单的分形树：        delta
LS文法构图算法(1) 简介
-第二月-的专栏
01-17 5279
        文法构图算法是仿照语言学中的语法生成方法来构造图形的一种算法。        任何语言都是由一个字母集和一些构成有意义语句的文法规则组成的。        著名语言学家N.Chomsky在20世纪50年代给出了递归生成语法的方法，指定一个或几个初始字母和一组“生成规则”，将生成规则反复作用到初始字母和新生成的字母上，产生出整个语言。比如：字母表：A, B生成规则：A
【分形算法】Jason带你飞之1——LS文法的java实现
weixin_34081595的博客
12-07 285
2019独角兽企业重金招聘Python工程师标准>>> ...
java：绘制分形树_【作业】简单分形树绘制程序
weixin_29614223的博客
02-26 158
1.项目名称：简单分形树绘制程序2.项目内容设计一个简单的分形树显示程序，能够绘制几棵分形的树状图形。3.功能设计思路利用MFC制作这样一个绘图程序！采用随机LS文法，该方法在LS文法中引入随机变量。通过鼠标双击视图变化生成的分形植物，可以提高自己对于MFC基本架构的理解，提高自己的VC++编程能力，对于分形算法有所理解！4.编码实施首先建立一个利用向导生成一个MFC程序名为Tree；右击菜单画圆...
基于python绘制l-system分形图
06-28
如果想基于Python绘制L-system分形图，可以通过turtle库实现。具体方法可以先定义L-system产生的字符串，再定义对应的绘制规则，最后根据规则使用turtle库绘制图形。可以参考一些已有的L-system代码进行学习和实践。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AiMateZero

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值