精华内容
下载资源
问答
  • 研究论文-一种基于迭代函数系统的分形图像编码方法
  • 为实现对自然界树木的逼真模拟,以迭代函数系统为基础,定义了三维空间上的变换矩阵,建立了三维植物生成模型,以一组压缩仿射变换生成的图像为例,通过调整已有IFS码的比例系数,可实现树木生长过程的模拟;通过调整IFS码...
  • 迭代函数系统生成分形

    千次阅读 2017-12-06 00:53:38
    迭代函数系统(Iterated Function System,IFS)可以用来创建分形图案,他所创建的图形永远是自相似的。 有一个很著名的树叶图形的绘制便是使用了此原理。 在一个二维平面中,有4种映射函数,可以将一个...
    迭代函数系统(Iterated Function System,IFS)可以用来创建分形图案,他所创建的图形永远是自相似的。
    有一个很著名的树叶图形的绘制便是使用了此原理。

    在一个二维平面中,有4种映射函数,可以将一个点映射到另一个 位置:

    1.
        x(n+1)= 0
        y(n+1) = 0.16 * y(n)

    2.
        x(n+1) = 0.2 * x(n) − 0.26 * y(n)
        y(n+1) = 0.23 * x(n) + 0.22 * y(n) + 1.6

    3.
        x(n+1) = −0.15 * x(n) + 0.28 * y(n)
        y(n+1) = 0.26 * x(n) + 0.24 * y(n) + 0.44

    4.
        x(n+1) = 0.85 * x(n) + 0.04 * y(n)
        y(n+1) = −0.04 * x(n) + 0.85 * y(n) + 1.6


    可以看到,x(n+1)是x(n)和y(n)的函数,y(n+1)也是如此。即这一次的计算要使用到上一次的结果,因此称之为迭代。给定一个初始点 x(0),y(0),经过上面的映射函数的映射,便可以得到平面中许多点,这些点构成的图形便是分形图案。这个系统就叫做迭代函数系统。
    但是,一共有4个映射函数,我怎么知道每次迭代是要使用哪一个呢?
    因此,还需要给每个映射函数规定一个概率,按照概率来进行选择。

    源码如下,注释很详细:

    # 分形树叶
    import numpy as np
    import matplotlib.pyplot as pl
    import time

    # 蕨类植物叶子的迭代函数和概率
    eq1 = np.array([[0,0,0],[0,0.16,0]])
    p1 = 0.01
    eq2 = np.array([[0.2,-0.26,0],[0.23,0.22,1.6]])
    p2 = 0.07
    eq3 = np.array([[-0.15, 0.28, 0],[0.26,0.24,0.44]])
    p3 = 0.07
    eq4 = np.array([[0.85, 0.04, 0],[-0.04, 0.85, 1.6]])
    p4 = 0.85

    def ifs(p, eq, init, n):
        # 迭代向量的初始化
        pos = np.ones(3, dtype=np.float)
        pos[:2] = init # pos=[x,y,1]

        # 通过函数概率,计算函数的选择序列
        p = np.add.accumulate(p) # 累加,[p1,p1+p2,p1+p2+p3,...]
        rands = np.random.rand(n) # array,0~1的随机数,长度为10
        select = np.ones(n, dtype=np.int) # 想要得到的效果:select[i]=m表示第i个序列为m(0<=m<=len(p)-1)
        for i,x in enumerate(p[::-1]): # p[x:y:z]表示从x遍历到y,间隔为z。p[::-1]表示将前两个省略,间隔为-1,前两个默认为p[len(p)-1]到p[0]
            select[rands<x] = len(p)-i-1 # i=0时,x=p[len(p)-1]一定为1,因此第一步所有位置都赋为 len(p)-1。i=1时,x小于1,有一部分会满足rands<x。这一部分被赋值为 len(p)-2。这两次迭代的差集会永远被赋值为 len(p)-1不会变,则这个差集上的所有序列永远选择了第 len(p)-1 个迭代函数。

        # 结果的初始化
        result = np.zeros((n,2), dtype=np.float)
        c = np.zeros(n, dtype=np.float)

        for i in range(n):
            eqidx = select[i] # 所选函数的下标
            temp = np.dot(eq[eqidx], pos) # 迭代公式
            pos[:2] = temp # 更新迭代向量

            # 保存结果
            result[i] = temp # 第i次的结果:[x,y]
            c[i] = eqidx # 第i次的选择

        return result[:,0],result[:,1],c

    start = time.clock()
    x, y, c = ifs([p1,p2,p3,p4],[eq1,eq2,eq3,eq4], [0,0], 10000)
    print(time.clock() - start)
    pl.figure(figsize=(6,6))
    pl.subplot(121)
    pl.scatter(x, y, s=1, c="g", marker="s", linewidths=0) # s=1表示散列点大小为1,c="g"表示点的颜色为green,marker="s"表示点的形状为正方形(速度最快)
    pl.axis("equal")
    pl.axis("off")
    pl.subplot(122)
    pl.scatter(x, y, s=1,c = c, marker="s", linewidths=0) # c=c表示按照每次迭代选择的序列来作为颜色,方便知道四个函数产生的点的大概位置
    pl.axis("equal")
    pl.axis("off")
    pl.subplots_adjust(left=0,right=1,bottom=0,top=1,wspace=0,hspace=0)
    pl.gcf().patch.set_facecolor("white")
    pl.show()

    结果如下:


    叶子上的每一个枝叶,都与原叶形状相同。
    右图的蓝色枝干为1%的函数生成的点,蓝色和绿色的两个叶子是概率为7%的函数生成的点,剩下的黄色叶子为85的函数生成的点。

    实验一:
    以上是10万个点生成的图。如果改为1000个点,效果如下:

    可以看出:
    1、点的产生并不是从下而上累计的,而是每次都会有一定概率落在某个映射函数的结果集所在位置上,随着点数的增多,轮廓越来越明显和精细。
    2、当起始点定了之后,每一个映射函数都有自己的一个映射空间,不会超出这个空间。比如两个7%的函数的映射空间就是在蓝叶子和绿叶子的轮廓中,不会跳出这个范围。

    实验二:
    将起始点(0,0)改为不均衡的数,如(10,1),(-1,10)等。发现结果的形状相同。说明与起始点的值无关。这是因为,映射函数是坐标的线性变换,也是仿射变换,即不改变原有的直线性和平行性,只是进行翻转和伸缩。因此在同一个函数的作用下,两个不同位置的点进行的翻转动作是相同的,因此得到的结果形状也是相同的。

    展开全文
  • 内容索引:VC/C++源码,算法相关,二维,分形绘图,函数 二维IFS迭代函数系统分形绘图,看似树叶,实际上运用了很多算法才生成的图形。程序功能:改变视图、颜色设置、绘制命令、参数设置等,可以绘图进行一些自定义。
  • 迭代函数系统(IFS)

    千次阅读 2017-11-15 17:18:30
    迭代函数系统(IFS) IFS库源码已经上传GitHub fractal,需查看源码的请挪步。 自定义概率迭代函数 代码: # Sier三角变换 from fractal import IFS from random import randint def ifsp(x, y): p ...

    迭代函数系统(IFS)

    IFS库源码已经上传GitHub fractal,需查看源码的请挪步。

    自定义概率迭代函数

    代码:

    # Sier三角变换
    from fractal import IFS
    from random import randint
    
    
    def ifsp(x, y):
        p = randint(1, 3)
        if p == 1:
            return (0.5 * x, 0.5 * y)
        elif p == 2:
            return (0.5 * x + 0.5, 0.5 * y + 0.5)
        else:
            return (0.5 * x + 0.5, 0.5 * y)
    
    ob = IFS([460, 450], title="Sier")
    ob.setPx(400, 0, 10)
    ob.setIfsp(ifsp)
    ob.doIFS(200000)
    ob.wait()

    结果:

    代码:

    # 蕨类IFS生成
    
    from fractal import IFS
    from random import random
    
    
    def ifsp(x, y):
        p = random()
        if p < 0.01:
            return (0, 0.16 * y)
        elif p < 0.07:
            if random() > 0.5:
                return (0.21 * x - 0.25 * y, 0.25 * x + 0.21 * y + 0.44)
            else:
                return (-0.2 * x + 0.26 * y, 0.23 * x + 0.22 * y + 0.6)
        else:
            return (0.85 * x + 0.1 * y, -0.05 * x + 0.85 * y + 0.6)
    
    ob = IFS([400, 500], title = "")
    ob.setPx(100, 100, 100)
    ob.setIfsp(ifsp)
    ob.doIFS(200000)
    ob.wait()

    结果:

    代码:

    # Box IFS
    from fractal import IFS
    from random import randint
    
    
    def ifsp(x, y):
        p = randint(1, 5)
        if p == 1:
            return (x / 3, y / 3)
        elif p == 2:
            return (x / 3 + 2 / 3, y / 3)
        elif p == 3:
            return (x / 3 + 1 / 3, y / 3 + 1 / 3)
        elif p == 4:
            return (x / 3, y / 3 + 2 / 3)
        else:
            return (x / 3 + 2 / 3, y / 3 + 2 / 3)
    
    ob = IFS([500, 500], title="Box")
    ob.setPx(490, 5, 5)
    ob.setIfsp(ifsp)
    ob.doIFS(200000)
    ob.wait()

    结果:

    使用IFS码进行迭代

    代码:

    from fractal.IFS import IFS
    
    ifscode = [
        [0.879, 0.054, -0.051, 0.878, 0.077, 0.123, 0.123],
        [0.1, -0.193, 0.285, 0.224, 0.174, 0.169, 0.169],
        [0.008, 0.135, 0, 0.204, 0.075, 0.074, 0.074],
        [0.402, 0.045, 0.016, -0.197, 0.111, 0.193, 0.193]
    ]
    
    ifs = IFS([500, 500])
    # ifs.setCoordinate()
    ifs.setPx(700, 0, 0)
    ifs.setIfsCode(ifscode)
    ifs.doIFS(200000)
    ifs.wait()
    

    结果:

    代码:

    from fractal.IFS import IFS
    
    code = [
        [0.195, -0.488, 0.344, 0.443, 0.4431, 0.2452, 0.2],
        [0.462, 0.414, -0.252, 0.361, 0.2511, 0.5692, 0.2],
        [-0.637, 0, 0, 0.501, 0.8562, 0.2512, 0.2],
        [-0.035, 0.07, -0.469, 0.022, 0.4884, 0.5069, 0.2],
        [-0.058, -0.07, -0.453, -0.111, 0.5976, 0.0969, 0.2]
    ]
    
    ifs = IFS([500,500])
    ifs.setCoordinate()
    ifs.setPx(500, 0, 0)
    ifs.setIfsCode(code)
    ifs.doIFS(200000)
    ifs.wait()

    结果:

    展开全文
  • 提出了一个新颖的基于迭代函数系统的干笔飞白效果仿真模型,能够较好地再现干笔中的随机性留白效果。模型采用迭代函数系统作为建模工具,根据运笔的速度和压力,采用随机迭代算法生成笔迹点集,通过绘制点集来模拟干...
  • 为实现对自然界树木的逼真模拟,以迭代函数系统为基础,定义了三维空间上的变换矩阵,建立了三维植物生成模型,以一组压缩仿射变换生成的图像为例,通过调整已有IFS码的比例系数,可实现树木生长过程的模拟;通过调整IFS码...
  • 对分形图形的一种构造方法——随机迭代函数系统 ,给出了确定一个随机迭代函数系统的原图像经过仿射变换后得到的新图像所对应的随机迭代函数系统的具体步骤 ,最后用平移、旋转、拉伸和对称变换的例子作了详细的说明。
  • 以提高水印的鲁棒性和图像质量为着眼点,提出了一种基于局部迭代函数系统(LIFS)的数字水印技术。利用原始图像与恢复图像的分形参数不变性,将水印信息嵌入到灰度补偿因子中。实验结果表明本文的方法在一定程度上...
  • 基本面-IFS Chris Metcalfe 的代码改编。 为“计算机科学的理论基础”主席所做的工作。 植物模型和迭代函数系统
  • 阐述了在图像压缩中的迭代函数系统的理论,并利用自动机理论对其吸引子相关的迭代函数系统的不确定性进行了探讨,从数学的角度给予了论证.
  • 讨论了弱压缩无穷共形迭代函数系统及其Ruelle算子,利用Ruelle算子得到此迭代函数系统的Perron- Frobenius性质.
  • 建立大量分形的简单方法
  • [6.837]A0:迭代函数系统(IFS)

    千次阅读 2017-10-10 23:58:23
    将初始点进行迭代,根据n个仿射变换的选取概率来决定究竟每一次迭代函数。这一段依概率选取的代码也使用伪随机实现: //以概率p来选择仿射变换j int j = 0 ; //初始化区间(a,b] double a = 0 , b...

    任务概述

    6.837的第一个作业,实现IFS。目的是熟悉C++的语法特性,并且熟悉使用两个和图像生成和线性代数相关的简单库。通过生成一些奇妙的分形物体来体会图形学的乐趣。
    IFS 是一种构造分形的方法,得到的分形通常是自相似(self-similar)的。IFS最经典的例子是绘制一种蕨类植物(Barnsley’s fern),如下图所示,可以看到,每一个子叶片与整个叶片的形状相同。
    Barnsley's fern
    IFS由一个仿射变换(affine transformations)集合所定义,通常定义的仿射变换包括旋转(rotation)、缩放(scale)、平移(translations)、斜切(skew)等等线性变换方法。这些变换不着了自相似的物体形状。IFS可以定义在多个维度上,在这个作业中,我们只需实现二维的变换。形式上来说,IFS由n个仿射变换组成,可以由如下公式表示:
    IFSformula
    每一个变换函数fi一定是收缩的,这意味着两点之间的距离必须减小。IFS的吸引子(attractor)是使得等式A=Ufi(A)成立的物体A,经历了这个集合的变换过程之后,物体A的形状不发生改变,也可以将其看作仿射变换集函数的不动点(fixed-point)。
    我们最后将渲染结果输出为图片。通过在一个单位正方形内随机采样点作为输入,通过多次迭代得到不动点,算法伪码描述如下:

    for "lots" of random points (x0, y0)
           for k=0 to num_iters 
               pick a random transform fi
               (xk+1, yk+1) = fi(xk, yk)
           display a dot at (xk, yk)

    实现细节

    1.命令行输入处理

    ifs -input fern.txt -points 10000 -iters 10 -size 100 -output fern.tga

    上述参数依次为:程序名、IFS数据文件名、随机点个数、迭代次数、图片大小、输出图片名。
    2.IFS类

    class IFS
    {
    public:
        //构造函数,使用仿射变换个数初始化
        IFS(int transnum);
        ~IFS();
        //仿射变换的个数
        int m_nNumofTrans;
        //仿射变换矩阵数组
        Matrix* m_matMatsofTrans;
        //每一个仿射变换的选取概率数组
        double* m_darrProbofTrans;
        // 读取IFS输入
        void ReadInput(FILE* filename);
        //绘制IFS图片
        void RenderIFS(Image* img, int pntnum, int iternum);
    };

    3.选择仿射变换
    对于算法的伪码描述,我在RenderIFS函数中给出实现。需要注意的是,对于多个随机输入点,首先要将其归一化,在这里我使用伪随机生成【0,1】区间上的浮点数。将初始点进行迭代,根据n个仿射变换的选取概率来决定究竟每一次迭代的函数。这一段依概率选取的代码也使用伪随机实现:

    //以概率p来选择仿射变换j
            int j = 0;
            //初始化区间(a,b]
            double a = 0, b = this->m_darrProbofTrans[j];
            double p = rand()*1.0f / RAND_MAX;
            for (j = 1; j < this->m_nNumofTrans; j++){
                //如果伪随机得到的p落在当前区间内,则跳出循环
                if (p > a&&p <= b){
                    break;
                }
                //按照概率更新区间
                a = b;
                b = b + this->m_darrProbofTrans[j];
            }
            //循环结束后j即为最终选取的仿射变换函数fj

    4.计算并绘制点
    每一次仿射变换都可以通过向量和矩阵的线性乘法得到,在这里我调用了Matrix类下的Transform函数。计算得到的最终点依然位于单位正方形中,将其映射到图片空间的过程,除了x,y轴向上的按比例放大之外,还要将浮点型离散为[0,size-1]的整型,防止数组下标越界。完成后即可通过Image类下的SetPixel函数将最终的点着色。


    结果展示

    1.Sierpinski Triangle
    谢尔宾斯基三角形分形

    2.Giant-X
    大x分形

    3.Fern
    这里写图片描述


    心得体会

    对于分形图形的绘制,IFS给出了简洁的设计思路。作为图形学的入门课程,MIT6.837的第一个作业很好的练习了C++的语法特性和线性代数的基本应用。

    展开全文
  • 迭代函数系统与CAD在纺织工业中的应用.pdf
  • 隐马尔可夫过程中的迭代函数系统及其动力学分析,陈双平,郑浩然,研究了隐马尔可夫过程中的迭代函数系统,给出了其动力学方程。以二态隐马尔可夫过程为例,描述了其在不同参数时不同的动力学行为
  • 基于迭代函数系统和分形插值的甲骨字形轮廓修复方法.pdf
  • Python:迭代函数系统(IFS)

    千次阅读 2018-12-26 11:10:56
    # -*- coding: utf-8 -*- import numpy as np import matplotlib.pyplot ...# 蕨类植物叶子的迭代函数和其概率值 eq1 = np.array([[0,0,0],[0,0.16,0]]) p1 = 0.01 eq2 = np.array([[0.2,-0.26,0],[0.23,0.22,1.6]...
    # -*- coding: utf-8 -*-
    import numpy as np
    import matplotlib.pyplot as pl
    import time
    
    # 蕨类植物叶子的迭代函数和其概率值
    eq1 = np.array([[0,0,0],[0,0.16,0]])
    p1 = 0.01
    
    eq2 = np.array([[0.2,-0.26,0],[0.23,0.22,1.6]])
    p2 = 0.07
    
    eq3 = np.array([[-0.15, 0.28, 0],[0.26,0.24,0.44]])
    p3 = 0.07
    
    eq4 = np.array([[0.85, 0.04, 0],[-0.04, 0.85, 1.6]])
    p4 = 0.85
    
    def ifs(p, eq, init, n):
        """
        进行函数迭代
        p: 每个函数的选择概率列表
        eq: 迭代函数列表
        init: 迭代初始点
        n: 迭代次数
        
        返回值: 每次迭代所得的X坐标数组, Y坐标数组, 计算所用的函数下标
        """
        
        # 迭代向量的初始化
        pos = np.ones(3, dtype=np.float)
        pos[:2] = init
        
        # 通过函数概率,计算函数的选择序列
        p = np.add.accumulate(p)
        rands = np.random.rand(n)
        select = np.ones(n, dtype=np.int)*(n-1)
        for i, x in enumerate(p[::-1]):
            select[rands<x] = len(p)-i-1
        
        # 结果的初始化
        result = np.zeros((n,2), dtype=np.float)
        c = np.zeros(n, dtype=np.float)
        
        for i in range(n):
            eqidx = select[i] # 所选的函数下标
            tmp = np.dot(eq[eqidx], pos) # 进行迭代
            pos[:2] = tmp # 更新迭代向量
            
            # 保存结果
            result[i] = tmp
            c[i] = eqidx
        
        return result[:,0], result[:, 1], c
    
    start = time.clock()
    x, y, c = ifs([p1,p2,p3,p4],[eq1,eq2,eq3,eq4], [0,0], 100000)
    print(time.clock() - start)
    pl.figure(figsize=(6,6))
    pl.subplot(121)
    pl.scatter(x, y, s=1, c="g", marker="s", linewidths=0)
    
    pl.axis("equal")
    pl.axis("off")
    pl.subplot(122)
    pl.scatter(x, y, s=1,c = c, marker="s", linewidths=0)
    pl.axis("equal")
    pl.axis("off")
    pl.subplots_adjust(left=0,right=1,bottom=0,top=1,wspace=0,hspace=0)
    pl.gcf().patch.set_facecolor("white")
    pl.show()

    程序运行结果:

    展开全文
  • 第2章 迭代函数系统  2.1 压缩映射  2.2 迭代函数系统(IFS)  2.3 拼贴定理 第3章 一般图像的分形压缩方法  3.1 图像的表示方法与图像的均方误差  3.2 分形压缩的简化方法  3.3 压缩实例  3.4 问题与改进...
  • 这个 cIntBMP 库提供创建 BMP 格式图像。我们将要讨论的例子,是关于使用 Iterated Function System (IFS - 迭代函数系统) 创建自相似分形集合。
  • 分形迭代系统(IFS)

    2011-03-04 23:59:27
    此程序完全使用html5的canvas特性,纯javascript开发。最适合的浏览器是opera和chrome,其他支持html5的浏览器:firefox4, ie9,... 程序是一个分形迭代系统的展示,画面非常好看。 请关注我的微博t.sina.com.cn/wjjnova
  • 最近在写RN相关的东西,其中涉及到了redux-saga ,saga的实现原理就是ES6中的Generator函数,而Generator函数又和迭代器有着密不可分的关系。所以本篇博客先学习总结了iterator相关的东西,然后又介绍了Generator...
  • 针对一类有限区间上重复运行的离散时变SISO系统,分别采用带饱和函数和死区修正的投影算法进行参数估计,提出自适应迭代学习控制方案.关键技术引理在分析离散自适应控制系统时起到了关键作用,文中把这一引理推广至迭代...
  • 《算子迭代与自相似集》不仅介绍算子迭代生成的迭代函数系统和自相似集的Hausdorff测度一般理论,而且还论述了近年来关于迭代函数系统和自相似集的Hausdorff测度的若干新理论与新方法,以及相关的公开问题。...
  • 本文利用函数逼近方法对丢包数据进行估计,分析网络化迭代学习控制系统的跟踪性能。 首先,本文阐述了迭代学习控制及网络控制的基本概念和原理,分析了其优越性,列举了它们在工程领域的重要应用,阐明了迭代学习...
  • 算法(Algorithm),是程序设计的灵魂,它是利用系统的方法描述解决问题策略的机制。本系列文章旨在用C语言解释算法的作用,分析包括排序算法、查找算法、迭代算法、递推算法、 递归算法、枚举算法、贪心算法、回溯...
  • 用高斯赛德尔方法求解... 考虑线性系统模型: A*x=b ,函数 sintax 是: [x,execution_time]=itergauss(A,b,n) [x] 是解向量A 是问题的线性矩阵b 是已知项向量n 是迭代逼近的次数execution_time是解决系统所需的时间
  • Python内置函数

    万次阅读 多人点赞 2019-05-10 15:10:36
    Python内置函数Python abs()函数Python all() 函数Python any() 函数Python basestring() 函数Python bin() 函数Python bool() 函数Python bytearray() 函数Python callable() 函数Python chr() 函数Python ...
  • 本文利用函数逼近方法对丢包数据进行估计,分析网络化迭代学习控制系统的跟踪性能。 首先,本文阐述了迭代学习控制及网络控制的基本概念和原理,分析了其优越性,列举了它们在工程领域的重要应用,阐明了迭代学习...
  • 该项目包括Matlab函数,用于通过迭代检测和解码来模拟MIMO和均衡系统 授权书 该项目包括Matlab中的代码,以模拟数字通信系统。 该代码主要由I. Santos和JJ Murillo Fuentes生成。 领有牌照 根据知识共享署名-非商业...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 222,469
精华内容 88,987
关键字:

迭代函数系统