精华内容
下载资源
问答
  • Mandelbrot集合让初始的z0=0z_{0}=0z0​=0,得到序列c,c2+c,(c2+c)2+c,… c,c^2+ c,(c^2+ c)^2+ c,…c,c2+c,(c2+c)2+c,…Julia集合则是给出一个固定c值决定它的形状,得到序列z,z2+c,(z2+c)2+c,…z,z^2+ c,
  • 易语言Julia集图片源码,Julia集图片,Julia
  • c++画分形之Julia集

    2017-01-05 14:05:49
    c++画分形之Julia集
  • 该代码生成 Julia 分形并将生成的集合作为 RGB 图形显示在您的屏幕上。
  • 方法采用二阶的Julia集f(Z)=Z2+C的时间逃逸算法,对于不同的C生成不同的曲线。然后使用Logistic混沌映射随机地产生0-255之间的整数填满量化表。再根据灰度量化规则,用第一千张量化表量化产生的Julia图像块,作为...
  • 运行main.py 单击或使用箭头更改函数z→z 2 + c中的常数c ,您将获得此函数的囚禁集-Julia集的边界。 按ctrl + S将囚犯集导出为位图(PNG)。 后台将Mandelbrot设置为“地图”。 要求: pygame sortedcontainers ...
  • 广义Julia集的控制,王兴元,宋文静,本文阐述了在复迭代函数 上利用一个恰当的数学变换实现了完整的放大和缩小,沿x轴和y轴方向上的伸缩以及广义Julia集的旋转,并且所�
  • Julia集分形

    2021-04-20 03:20:07
    我写了一个程序来生成Julia集分形。该程序还允许用户输入其值c或让程序生成一个随机值。代码如下:import pygame, sys, math, cmath, randomfrom pygame.locals import *print("Julia set fractal generator")custom...

    我写了一个程序来生成Julia集分形。该程序还允许用户输入其值c或让程序生成一个随机值。代码如下:import pygame, sys, math, cmath, random

    from pygame.locals import *

    print("Julia set fractal generator")

    custom = int(input("Do you want a custom set? Yes(1); No(-1): "))

    if custom == -1:

    c = complex((random.randint(-999,1000))/1000.0,(random.randint(-999,1000))/1000.0)

    else:

    a = float(input("Real?: "))

    b = float(input("Imaginary?: "))

    c = complex(a,b)

    lim = 4

    limn = -4

    mul = 0

    iteration_detail = 100

    screen = pygame.display.set_mode((512,512),0,32)

    pygame.display.set_caption("Julia set fractal generator")

    def iterate (px_i,py_i,iters):

    itnum = 1

    z = complex(((px_i-256)/512.0)*4,((py_i-256)/512.0)*4)

    while itnum <= iters:

    if z.real >= lim or z.imag >= lim or z.real <= limn or z.imag <= limn:

    break

    z = z**2 + c

    itnum += 1

    return(z.real, z.imag, itnum)

    def pixel_color_set (iterx, itery, iterations):

    pixel_color = (0,0,0)

    if iterx >= lim or itery >= lim or iterx <= limn or itery <= limn:

    if iterations < 2:

    pixel_color = (204,0,102)

    elif iterations == 2:

    pixel_color = (204,0,204)

    elif iterations == 3:

    pixel_color = (102,0,204)

    elif iterations ==4:

    pixel_color = (0,0,204)

    elif iterations ==5:

    pixel_color = (0,102,204)

    elif iterations ==6:

    pixel_color = (0,204,204)

    elif iterations ==7:

    pixel_color = (0,204,102)

    elif iterations ==8:

    pixel_color = (0,204,0)

    elif iterations ==9:

    pixel_color = (102,204,0)

    return(pixel_color)

    def draw_pixel (px, py, color):

    return(screen.fill(color, ((px, py),(1, 1))))

    while 1:

    for event in pygame.event.get():

    if event.type == QUIT:

    pygame.quit()

    sys.exit()

    if event.type == KEYDOWN:

    if event.key == K_UP:

    mul = 0.1

    elif event.key == K_DOWN:

    mul = -0.1

    if event.key == K_SPACE:

    pygame.image.save(screen, "fractal.jpg")

    if event.type == KEYUP:

    if event.key == K_UP:

    mul = 0

    elif event.key == K_DOWN:

    mul = 0

    c += mul

    ypxl = 0

    while ypxl < 512:

    xpxl = 0

    while xpxl < 512:

    ipxl = iterate(xpxl,ypxl,iteration_detail)

    cpxl = pixel_color_set(ipxl[0], ipxl[1], ipxl[2])

    draw_pixel(xpxl, ypxl, cpxl)

    xpxl += 1

    ypxl += 1

    pygame.display.update()

    代码确实有效,但并没有像预期的那样生成分形。例如这个分形:-

    z = z**2 + c其中c等于

    c = complex(-0.1, 0.651)

    应该是这样的

    bjzU7.png

    但看起来是这样的

    rzbq4.jpg

    我的代码有什么问题?我也不能做一个缩放机制。。。如果有人帮忙,我将不胜感激。在

    展开全文
  • 此函数显示了 P(z) = z^2 + C 形式的函数的 Julia 边界的近似值。逆迭代是一种通过执行 z = sqrt(zc) 来计算 z 先前值的方法。 通过这样做,获得沿边界的点。 由于 sqrt 将给出两种可能的答案,因此该函数将随机...
  • python交互绘制Julia集

    千次阅读 2019-10-13 10:16:02
    matplotlib的Show面板中提供了放大、移动等交互式操作,但也未能涵盖所有的交互需求,比如希望通过mandelbrot集上的一点来生成对应的Julia集


    matplotlib的Show面板中提供了放大、移动等交互式操作,但也未能涵盖所有的交互需求,比如希望通过mandelbrot集上的一点来生成对应的Julia集。所谓Julia集就是类似下面的美妙的图案
    在这里插入图片描述

    Julia集

    此Julia非彼Julia,乃是传说中的分形鼻祖,指的是对于给定的一个复数 c c c,使得迭代式 f ( z ) = z 2 + c f(z)=z^2+c f(z)=z2+c收敛的复数 z z z的集合。例如,当 c = 0 c=0 c=0时,那么其收敛区间为 z 2 < 1 z^2<1 z2<1的单位圆,对应的 c c c的Julia集便是 cos ⁡ θ + i sin ⁡ θ \cos\theta+i\sin\theta cosθ+isinθ
    特别地,当 c = z c=z c=z的初始值时,符合收敛条件的 z z z的便构成大名鼎鼎的Mandelbrot集
    Mandelbrot集在上图中,颜色表示该点的发散速度,可以理解为开始发散时迭代的次数。其生成代码也非常简单:

    #mbrot.py
    import numpy as np
    import time
    import pyplotlib.pyplot as plt
    #生成z坐标,axis为起始位置,nx,ny为x向和y向的格点个数
    def genZ(axis,nx,ny):
        x0,x1,y0,y1 = axis
        x = np.linspace(x0,x1,nx)
        y = np.linspace(y0,y1,ny)
        real, img = np.meshgrid(x,y)
        z = real + img*1j
        return z
    #获取Julia集,n为迭代次数,m为判定发散点,大于1即可
    def getJulia(z,c,n,m=2):
        t = time.time()
        c = np.zeros_like(z)+c
        out = abs(z)
        for i in range(n):
            absz = abs(z)
            z[absz>m]=0		#对开始发散的点置零
            c[absz>m]=0		
            out[absz>m]=i	#记录发散点的发散速度
            z = z*z + c
        print("time:",time.time()-t)
        return out
    if __name__ == "__main__":
        axis = np.array([-2,1,-1.5,1.5])
        z0 = genZ(axis,500,500)
        mBrot = getJulia(z0,z0,50)
        plt.imshow(mBrot, cmap=cm.jet, extent=axis)
        plt.gca().set_axis_off()
        plt.show()
    

    matplotlib绑定事件

    下面希望实现点击Mandelbrot集中的一点,生成相应的Julia集。
    在mpl中,事件绑定函数mpl_connect被封装在cavnas类中,调用格式为canvas.mpl_connect('str', func),其中func事件函数,字符串为被传入事件函数的事件标识,如下所列,望文生义即可

    'button_press_event'
    'button_release_event'
    'draw_event'
    'key_press_event'
    'key_release_event'
    'motion_notify_event'
    'pick_event'
    'resize_event'
    'scroll_event'
    'figure_enter_event'
    'figure_leave_event'
    'axes_enter_event'
    'axes_leave_event'
    'close_event'
    

    简单起见,可以先检测一下鼠标点击事件'button_press_event',对此我们需要定义一个事件函数,并将上面的入口函数稍加修改:

    def test(evt):
        print(evt.xdata)	#xdata即x方向的坐标
    if __name__ == "__main__":
        axis = np.array([-2,1,-1.5,1.5])
        z0 = genZ(axis,500,500)
        mBrot = getJulia(z0,z0,50)
        fig, ax = plt.subplots()
        fig.canvas.mpl_connect('button_press_event', test)#调用事件函数
        plt.imshow(mBrot, cmap=cm.jet, extent=axis)
        plt.gca().set_axis_off()
        plt.show()	
    

    于是点击imshow()出来的图片,即可返回相应的x坐标。

    python mbrot.py
    time: 0.47572827339172363
    -0.8652597402597402
    -0.7840909090909087
    -0.18344155844155807
    0.23051948051948123
    0.8149350649350655
    

    缩放

    那么生成Julia集只需要重新调用一次getJulia这个函数即可。
    Mandelbrot集的分形特征意味着我们所生成的图片可以无限放大,但是mpl自带的放大工具并不会重新生成数据,所以是虚假的放大。因此需要重新绑定放大操作,其思路是,当右键点击(‘button_press_event’)时,记录此时的坐标,当右键释(‘button_release_event’)放时重新绘制图片,为了防止与左键冲突,所以在点击所对应的事件函数中加入左右键判断。其结果如图
    在这里插入图片描述
    此外,还可以绑定鼠标滚轮,实现Mandelbrot集在该点的真实缩放,代码如下

    import matplotlib.pyplot as plt
    import numpy as np
    from matplotlib import cm
    import matplotlib.backend_bases as mbb
    import time
    
    class MandelBrot():
        def __init__(self,x0,x1,y0,y1,n):
            self.oriAxis = np.array([x0,x1,y0,y1])        	#初始坐标
            self.axis = self.oriAxis
            self.nx,self.ny,self.nMax = n,n,n               #x,y方向的网格划分个数
            self.nIter = 100                                #迭代次数
            self.n0 = 0                                     #预迭代次数
            self.z = genZ(self.oriAxis,self.nx,self.ny)
            self.DrawMandelbrot()
    
        def DrawMandelbrot(self):
            mBrot = getJulia(self.z,self.z,self.nIter)
            
            self.fig, ax = plt.subplots()
            plt.imshow(mBrot, cmap=cm.jet, extent=self.axis)
            plt.gca().set_axis_off()
            
            self.fig.canvas.mpl_disconnect(self.fig.canvas.manager.key_press_handler_id)
            self.fig.canvas.mpl_connect('button_press_event', self.OnMouse)
            self.fig.canvas.mpl_connect('button_release_event', self.OnRelease)
            self.fig.canvas.mpl_connect('scroll_event', self.OnScroll)
            
            plt.show()
    
        def DrawJulia(self,c0):
    
            z = genZ([-2,2,-2,2],800,800)
            julia = getJulia(z,c0,self.nIter)
            
            jFig,jAx = plt.subplots()
            plt.cla()
            plt.imshow(julia, cmap=cm.jet, extent=self.axis)
            plt.gca().set_axis_off()
            plt.show()
            jFig.canvas.draw_idle()
    	
    	#滚轮缩放
        def OnScroll(self,evt):
            x0,y0 = evt.xdata,evt.ydata
    
            if evt.button == "up":
                self.axis = (self.axis+[x0,x0,y0,y0])/2
            elif evt.button == 'down':
                self.axis = 2*self.axis-[x0,x0,y0,y0]
    
            z = genZ(self.axis,self.nx,self.ny)
            mBrot = getJulia(z,z,self.nIter)
            plt.cla()
            plt.imshow(mBrot, cmap=cm.jet, extent=self.axis)
            plt.gca().set_axis_off()
            
            mBrot[mBrot<1]==self.n0+self.nIter
            self.n0 = int(np.min(mBrot))
            self.fig.canvas.draw_idle()
            pass
    
        def OnMouse(self, evt):
            self.xStart = evt.xdata
            self.yStart = evt.ydata
            self.fig.canvas.draw_idle()
        
        def OnRelease(self,evt):
            x0,y0,x1,y1 = self.xStart,self.yStart,evt.xdata,evt.ydata
            if evt.button == mbb.MouseButton.LEFT:
                self.DrawJulia(x1+y1*1j)		#如果释放的是左键,那么就绘制Julia集并返回
                return
            #右键拖动,可以对Mandelbrot集进行真实的放大
            self.axis = np.array([min(x0,x1),max(x0,x1),
                                 min(y0,y1),max(y0,y1)])
            
            nxny = self.axis[[1,3]]-self.axis[[0,2]]
            self.nx,self.ny = (nxny/max(nxny)*self.nMax).astype(int)
            z = genZ(self.axis,self.nx,self.ny)
    
            n = 100     #n为迭代次数
            mBrot = getJulia(z,z,n)
            plt.cla()
            plt.imshow(mBrot, cmap=cm.jet, extent=self.axis)
            plt.gca().set_axis_off()
            
            mBrot[mBrot<1]==self.n0+n
            self.n0 = int(np.min(mBrot))
            self.fig.canvas.draw_idle()
    
    def genZ(axis,nx,ny):
        x0,x1,y0,y1 = axis
        x = np.linspace(x0,x1,nx)
        y = np.linspace(y0,y1,ny)
        real, img = np.meshgrid(x,y)
        z = real + img*1j
        return z
    
    def getJulia(z,c,n,n0=0,m=2):
        t = time.time()
        c = np.zeros_like(z)+c
        out = abs(z)
        for _ in range(n0):
            z = z*z + c
        for i in range(n0,n0+n):
            absz = abs(z)
            z[absz>m]=0
            c[absz>m]=0
            out[absz>m]=i
            z = z*z + c
        print("time:",time.time()-t)
        return out
    
    if __name__ == "__main__":
        x,y = 0,0
        brot = MandelBrot(-2,1,-1.5,1.5,1000)
    
    展开全文
  • high resolution Mandelbrot set and Julia set ( 2000x2000 pixel )Julia set and Mandelbrot set ,the zip file contains two m files1.juliaset3.m plots 16 different types of julia set( 2000 x 2000 pi...

    high resolution Mandelbrot set and Julia set ( 2000x2000 pixel )

    Julia set and Mandelbrot set ,the zip file contains two m files

    1.juliaset3.m plots 16 different types of julia set

    ( 2000 x 2000 pixels)

    2.fractal5.m plots Mandelbrot set (2000 x 2000 pixels )

    the figure can be saved in image by removing the comments

    in the last few lines of m file.

    you can see some of them here

    http://picasaweb.google.com/powerofankur/LargeFractalImages?feat=directlink

    展开全文
  • Mandelbrot集和Julia集的分形图之matlab实现基于逃逸时间算法1. Mandelbrot集function Mandelbrot(res,iter,xc,yc,xoom)%Mandelbrot% res是目标分辨率,iter是循环次数,(xc,yc)是图像中心,xoom是放大倍数x0=xc-2/...

    Mandelbrot集和Julia集的分形图之matlab实现

    基于逃逸时间算法

    1. Mandelbrot集

    function Mandelbrot(res,iter,xc,yc,xoom)

    %Mandelbrot

    % res是目标分辨率,iter是循环次数,(xc,yc)是图像中心,xoom是放大倍数

    x0=xc-2/xoom;x1=xc+2/xoom;

    y0=yc-2/xoom;y1=yc+2/xoom;

    x=linspace(x0,x1,res);

    y=linspace(y0,y1,res);

    [xx,yy]=meshgrid(x,y);

    z=xx+yy*1i;

    C=z;

    N=zeros(res,res); %初始化N,最终根据N,对各点进行染色

    tic %显示tic和toc间的程序运行时间

    for k=1:iter

    z=z.^2+C; %对空间上每点都进行迭代

    N(abs(z)>4)=k; %逃逸半径为4,诺某点逃逸,记录逃逸时间k,未逃逸则时间为0 z(abs(z)>4)=0;

    C(abs(z)>4)=0;

    end

    imshow(N,[]);

    toc

    end

    >>Mandelbrot(512,100,0,0,1)

    1-469-png_6_0_0_0_0_0_0_918_1188-918-0-0-918.jpg

    展开全文
  • Mandelbrot集和Julia集的分形图之matlab实现基于逃逸时间算法1. Mandelbrot集function Mandelbrot(res,iter,xc,yc,xoom)%Mandelbrot% res是目标分辨率,iter是循环次数,(xc,yc)是图像中心,xoom是放大倍数x0=xc-2/...
  • C语言画分形之Julia集

    千次阅读 2020-05-15 14:55:21
    最强大脑第四季有一位选手余彬晶挑战的就是“分形之美”,项目使用的是分形之Julia集,感兴趣的话可以看看 。下面进入正题: 分形 目前常用的造型技术 分形几何 背景 概念 对模型的基本要求 经典分形 利用graphic...
  • 以独立分量分析(ICA)技术作为主要研究对象,对基于独立分量分析的定点算法的进行了详细的分析和推理。传统定点算法具有结构简单、运算速度快的特点,但是在图像盲分离中数据有时不能完全满足独立性假设,因此在有些...
  • 目的构造双曲平面上极限圆中的混沌吸引子和广义充满Julia集。方法从双曲几何的角度分析了极限圆的内部结构及对称特性,将双曲映射限制在基本域内,并利用双曲极限圆基本域中点之间的距离特性,直接采用欧氏平面...
  • Julia集与Mandelbrot集

    千次阅读 2017-11-15 17:21:22
    Julia集与Mandelbrot集是由一个简单的复函数 z = z^2+c 迭代生成的图形,但是函数简单并不代表含义简单,这是分形的一大块。库源码已上传GitHub fractal,需要请自行查看,下面只介绍使用。 代码: from ...
  • 作者分析了重根牛顿变换的Julia集理论,并利用迭代法构造了标准牛顿变换、松弛牛顿变换和重根牛顿变换的Julia集。采用实验数学方法,作者得出如下结论:(1)函数f (g)=Za(zβ- 1)的三种牛顿变换Julia集的中心为原点且...
  • Julia3D 使用WebGL在3D中可视化的Julia集 当前版本仅使用常规的z ^ 2 + k算法,在n次迭代后,它将结果用作z值。
  • Julia集图片.rar

    2020-04-05 04:03:24
    Julia集图片.rar
  • Julia集简单实现示例

    千次阅读 2019-09-12 14:29:22
    原理 复数平面中某些点按照函数 f(z) = z^2 + c 进行...Julia集就是由非发散点组成的集合。 我们把这些点画出来就可以了。 但是我们不可能把所有点都找出来。只能认为在一定迭代次数(例如25)下,|z| < 2的点统...
  • 绘制Mandelbrot和Julia集的简单Java程序 如何使用 第一个输入参数必须是分形类型(Mandelbrot或Julia)。例如,如果您想要Mandelbrot, java Fractal Mandelbrot 仅提供一个参数将对其他参数使用默认值 您可以给4...
  • 为了绘制集合,查看器使用一组数据点作为 Mandelbrot 案例中的 c,或 Julia 案例中的 z_0,并根据发散所需的迭代次数为每个数据点生成颜色。 使用此代码,您最多可以放大和缩小 1E10 倍,并像查看常规绘图一样...
  • 此应用程序允许您借助功能强大的 GPU 在 MATLAB 中探索 Mandelbrot Julia 。 它主要用于演示使用 MATLAB 和 GPU 进行元素计算,但它也有一些有趣的功能: * 使用普通的 MATLAB 缩放和平移来浏览 Julia * ...
  • 用于生成分形形状的应用程序,例如 Mandelbrot Set 和 Julia Sets。 运行Mandelbrot_GUI.m并选择所有参数以进行分形的计算和可视化。
  • 朱丽叶塞特 生成图像。 创建它主要是作为JuliaBox托管REST API的示例。 要将其用作的REST API: 登录到 ... 转到“发布的API ”部分。 如果您没有看到它,则可能未为您启用。 请写信给或在留言,然后有人会... Juliaset.
  • 不同于以往对Julia集的研究仅限于对一个独立 的Julia集的性质,制图等方面的讨论,本文提出了两个不同的Julia集广义同步的思想,并以经典的复二次多项式系统zn+1=zn2+c为例,分别采用线性和非线性耦合的方法对该系统不同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,137
精华内容 1,654
关键字:

julia集