登录
当前位置： 首页 > 知识库问答 >
问题：

找不到一种方法来给曼德尔布罗特设定的目标上色

汪阳辉
2023-03-14

我已经成功地为Mandelbrot集上色，尽管我不能放大太远，直到它变得“模糊”并且图案停止。我通过增加max_迭代来解决这个问题，这是可行的，但在*1放大时，我得到的颜色很少，很多颜色只有在放大时才会出现。我理解为什么会发生这种情况，因为在一个“真实”的Mandelbrot集合中没有颜色，而增加max_迭代只会使它更接近这一点。但我的问题是，像youtube上这样的缩放在整个缩放过程中是如何拥有美丽的颜色的，同时还能永远放大？

我试着在网上到处寻找，但我找不到解决方案，当我查看这些youtube缩放的描述时，他们似乎几乎没有提供任何关于他们如何制作缩放的信息。

下面是绘制Mandelbrot集的代码部分。下面的代码是在processing中编写的，processing是java，并添加了可视化库。您可以在此处了解有关该计划的更多信息：https://processing.org/

//m is max_iterations
//mb is the function which calculates how many iterations each point took to escape to infinity. I won't be including the function since I know it works fine and it's quite messy.
//i'm using a HSB/HSV system to draw the mandelbrot

hue=(mb(x, y, m)*360)/m;
sat=255;
if (mb(x, y, m)<m) {
  val=255;
} 
else {
  val=0;
}

stroke(hue,sat,val);
point(x, y);

我明白为什么我的问题会发生，但我不知道如何解决它。

共有1个答案

姬向明
2023-03-14

首先看看这个相关的QA：

  • Mandelbrot集合-颜色光谱建议

其主要思想是使用直方图将颜色渐变更有效地分布到使用的索引上，而不是在未使用的索引上均匀地浪费许多颜色。它还使用了一个特定的视觉上令人愉快的渐变函数：

  • 可见光谱的RGB值

其他人建议的动态最大迭代次数计数只会影响整体性能和缩放中的细节。然而，如果你想在没有缩放的情况下获得漂亮的颜色，那么你需要计算浮点迭代次数，这也被称为Mandelbrot Escape。有一种数学方法可以从方程的最后一个子结果计算迭代次数分数部分。有关更多信息，请参阅：

  • 重新正规化Mandelbrot逃逸

但是我从来没有试过，所以带着偏见读这个：如果我读对了，你想要的是计算这个等式：

mu = m + frac = n + 1 - log (log  |Z(n)|) / log 2

其中，n是您的迭代计数，Z（n）是您正在迭代的方程的复域子结果。所以现在从mu计算颜色，它现在是浮点，而不是从n。。。

[Edit2]GLSL mandelbrot，基于上述链接的分数转义

我添加了分数转义，并修改了直方图多次重着色以匹配新的输出。。。

顶点：

// Vertex
#version 420 core
layout(location=0) in vec2 pos;     // glVertex2f <-1,+1>
out smooth vec2 p;                  // texture end point <0,1>
void main()
    {
    p=pos;
    gl_Position=vec4(pos,0.0,1.0);
    }

片段：

// Fragment
#version 420 core
uniform vec2 p0=vec2(0.0,0.0);      // mouse position <-1,+1>
uniform float zoom=1.000;           // zoom [-]
uniform int  n=100;                 // iterations [-]
uniform int  sh=7;                  // fixed point accuracy [bits]
uniform int  multipass=0;           // multi pass?
in smooth vec2 p;
out vec4 col;

const int n0=1;                     // forced iterations after escape to improve precision

vec3 spectral_color(float l)        // RGB <0,1> <- lambda l <400,700> [nm]
    {
    float t;  vec3 c=vec3(0.0,0.0,0.0);
         if ((l>=400.0)&&(l<410.0)) { t=(l-400.0)/(410.0-400.0); c.r=    +(0.33*t)-(0.20*t*t); }
    else if ((l>=410.0)&&(l<475.0)) { t=(l-410.0)/(475.0-410.0); c.r=0.14         -(0.13*t*t); }
    else if ((l>=545.0)&&(l<595.0)) { t=(l-545.0)/(595.0-545.0); c.r=    +(1.98*t)-(     t*t); }
    else if ((l>=595.0)&&(l<650.0)) { t=(l-595.0)/(650.0-595.0); c.r=0.98+(0.06*t)-(0.40*t*t); }
    else if ((l>=650.0)&&(l<700.0)) { t=(l-650.0)/(700.0-650.0); c.r=0.65-(0.84*t)+(0.20*t*t); }
         if ((l>=415.0)&&(l<475.0)) { t=(l-415.0)/(475.0-415.0); c.g=             +(0.80*t*t); }
    else if ((l>=475.0)&&(l<590.0)) { t=(l-475.0)/(590.0-475.0); c.g=0.8 +(0.76*t)-(0.80*t*t); }
    else if ((l>=585.0)&&(l<639.0)) { t=(l-585.0)/(639.0-585.0); c.g=0.84-(0.84*t)           ; }
         if ((l>=400.0)&&(l<475.0)) { t=(l-400.0)/(475.0-400.0); c.b=    +(2.20*t)-(1.50*t*t); }
    else if ((l>=475.0)&&(l<560.0)) { t=(l-475.0)/(560.0-475.0); c.b=0.7 -(     t)+(0.30*t*t); }
    return c;
    }

void main()
    {
    int i,j,N;
    vec2 pp;
    float x,y,q,xx,yy,mu;
    pp=(p/zoom)-p0;         // y (-1.0, 1.0)
    pp.x-=0.5;              // x (-1.5, 0.5)
    for (x=0.0,y=0.0,xx=0.0,yy=0.0,i=0;(i<n-n0)&&(xx+yy<4.0);i++)
        {
        q=xx-yy+pp.x;
        y=(2.0*x*y)+pp.y;
        x=q;
        xx=x*x;
        yy=y*y;     
        }
    for (j=0;j<n0;j++,i++)  // 2 more iterations to diminish fraction escape error
        {
        q=xx-yy+pp.x;
        y=(2.0*x*y)+pp.y;
        x=q;
        xx=x*x;
        yy=y*y;
        }
    mu=float(i)-log(log(sqrt(xx+yy))/log(2.0));
    mu*=float(1<<sh); i=int(mu);
    N=n<<sh;
    if (i>N) i=N;
    if (i<0) i=0;

    if (multipass!=0)
        {
        // i
        float r,g,b;
        r= i     &255; r/=255.0;
        g=(i>> 8)&255; g/=255.0;
        b=(i>>16)&255; b/=255.0;
        col=vec4(r,g,b,255);
        }
    else{
        // RGB
        q=float(i)/float(N);
        q=pow(q,0.2);
        col=vec4(spectral_color(400.0+(300.0*q)),1.0);
        }
    }

CPU端C/VCL代码：

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "gl\\OpenGL3D_double.cpp"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
OpenGLscreen scr;
GLSLprogram shd;
float mx=0.0,my=0.0,mx0=0.0,my0=0.0,mx1=0.0,my1=0.0;
TShiftState sh0,sh1;
int xs=1,ys=1;
float zoom=1.000;
int sh=7;
int N=256;
int _multi=0;
unsigned int queryID[2];
#define multi_pass
OpenGLtexture txr;
//---------------------------------------------------------------------------
DWORD spectral_color(float l)        // RGB <0,1> <- lambda l <400,700> [nm]
    {
    float t;  float r,g,b; DWORD c,x; r=0.0; g=0.0; b=0.0;
         if ((l>=400.0)&&(l<410.0)) { t=(l-400.0)/(410.0-400.0); r=    +(0.33*t)-(0.20*t*t); }
    else if ((l>=410.0)&&(l<475.0)) { t=(l-410.0)/(475.0-410.0); r=0.14         -(0.13*t*t); }
    else if ((l>=545.0)&&(l<595.0)) { t=(l-545.0)/(595.0-545.0); r=    +(1.98*t)-(     t*t); }
    else if ((l>=595.0)&&(l<650.0)) { t=(l-595.0)/(650.0-595.0); r=0.98+(0.06*t)-(0.40*t*t); }
    else if ((l>=650.0)&&(l<700.0)) { t=(l-650.0)/(700.0-650.0); r=0.65-(0.84*t)+(0.20*t*t); }
         if ((l>=415.0)&&(l<475.0)) { t=(l-415.0)/(475.0-415.0); g=             +(0.80*t*t); }
    else if ((l>=475.0)&&(l<590.0)) { t=(l-475.0)/(590.0-475.0); g=0.8 +(0.76*t)-(0.80*t*t); }
    else if ((l>=585.0)&&(l<639.0)) { t=(l-585.0)/(639.0-585.0); g=0.84-(0.84*t)           ; }
         if ((l>=400.0)&&(l<475.0)) { t=(l-400.0)/(475.0-400.0); b=    +(2.20*t)-(1.50*t*t); }
    else if ((l>=475.0)&&(l<560.0)) { t=(l-475.0)/(560.0-475.0); b=0.7 -(     t)+(0.30*t*t); }
    r*=255.0; g*=255.0; b*=255.0;
    x=r; c =x;
    x=g; c|=x<<8;
    x=b; c|=x<<16;
    return c;
    }
//---------------------------------------------------------------------------
void gl_draw()
    {
    scr.cls();

    // matrix for old GL rendering
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();


    // GLSL uniforms
    shd.bind();
    shd.set2f("p0",mx,my);          // pan position
    shd.set1f("zoom",zoom);         // zoom
    shd.set1i("n",N);               // iterations
    shd.set1i("sh",sh);             // fixed point accuracy (shift)
    shd.set1i("multipass",_multi);  // single/multi pass

    // issue the first query
    // Records the time only after all previous
    // commands have been completed
    glQueryCounter(queryID[0], GL_TIMESTAMP);

    // QUAD covering screen
    glColor3f(1.0,1.0,1.0);
    glBegin(GL_QUADS);
    glVertex2f(-1.0,+1.0);
    glVertex2f(-1.0,-1.0);
    glVertex2f(+1.0,-1.0);
    glVertex2f(+1.0,+1.0);
    glEnd();
    shd.unbind();

    // [multipas]
    if (_multi)
        {
        float t,m,n=N<<sh;
        DWORD *hist=new DWORD[n+1];
        int sz=txr.xs*txr.ys,i,j;
        // get rendered image
        glReadPixels(0,0,txr.xs,txr.ys,GL_RGBA,GL_UNSIGNED_BYTE,txr.txr);
        // compute histogram
        for (i=0;i<=n;i++) hist[i]=0;
        for (i=0;i<sz;i++) hist[txr.txr[i]&0x00FFFFFF]++;
        // histogram -> used color index (skip holes)
        for (i=1,j=1;i<=n;i++)
         if (hist[i]){ hist[i]=j; j++; }
        // used color index -> color
        m=1.0/float(j); hist[0]=0x00000000;
        for (i=1;i<=n;i++)
         if (hist[i]){ t=hist[i]; t*=m; hist[i]=spectral_color(400.0+(300.0*t)); }
          else hist[i]=0x00000000;
        // recolor image
        for (i=0;i<sz;i++) txr.txr[i]=hist[txr.txr[i]&0x00FFFFFF];
        // render it back
        scr.cls();
        txr.bind();
        glColor3f(1.0,1.0,1.0);
        glBegin(GL_QUADS);
        glTexCoord2f(0.0,1.0); glVertex2f(-1.0,+1.0);
        glTexCoord2f(0.0,0.0); glVertex2f(-1.0,-1.0);
        glTexCoord2f(1.0,0.0); glVertex2f(+1.0,-1.0);
        glTexCoord2f(1.0,1.0); glVertex2f(+1.0,+1.0);
        glEnd();
        txr.unbind();
        glDisable(GL_TEXTURE_2D);
        delete[] hist;
        }

    // issue the second query
    // records the time when the sequence of OpenGL
    // commands has been fully executed
    glQueryCounter(queryID[1], GL_TIMESTAMP);


    // GL driver info and GLSL log
    scr.text_init_pix(0.75);
    glColor4f(1.0,1.0,1.0,0.9);
    scr.text(glGetAnsiString(GL_VENDOR));
    scr.text(glGetAnsiString(GL_RENDERER));
    scr.text("OpenGL ver: "+glGetAnsiString(GL_VERSION));
    if (_multi) scr.text("Multi pass");
     else       scr.text("Single pass");
    if (shd.log.Length()!=41)
     for (int i=1;i<=shd.log.Length();) scr.text(str_load_lin(shd.log,i,true));
    scr.text_exit();

    scr.exe();
    scr.rfs();

    // wait until the results are available
    int e;
    unsigned __int64 t0,t1;
    for (e=0;!e;) glGetQueryObjectiv(queryID[0],GL_QUERY_RESULT_AVAILABLE,&e);
    for (e=0;!e;) glGetQueryObjectiv(queryID[1],GL_QUERY_RESULT_AVAILABLE,&e);
    glGetQueryObjectui64v(queryID[0], GL_QUERY_RESULT, &t0);
    glGetQueryObjectui64v(queryID[1], GL_QUERY_RESULT, &t1);
    Form1->Caption=AnsiString().sprintf("dt: %f ms p0:%.3fx%.3f zoom: %.1lf N:%i<<%i\n",(t1-t0)/1000000.0,mx,my,zoom,N,sh);
    }
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner):TForm(Owner)
    {
    scr.init(this);
    shd.set_source_file("","","","Mandelbrot_set.glsl_vert","Mandelbrot_set.glsl_frag");
    glGenQueries(2, queryID);
    // nice spirals
    _multi=1;
    zoom=300.0;
    mx  = 0.268;
    my  =-0.102;
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
    {
    scr.exit();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
    {
    scr.resize();
    xs=ClientWidth;
    ys=ClientHeight;
    txr.resize(xs,ys);
    gl_draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
    {
    gl_draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X,int Y)
    {
    bool q0,q1;
    mx1=1.0-divide(X+X,xs-1);
    my1=divide(Y+Y,ys-1)-1.0;
    sh1=Shift;
    q0=sh0.Contains(ssLeft);
    q1=sh1.Contains(ssLeft);
    if (q1)
        {
        mx-=(mx1-mx0)/zoom;
        my-=(my1-my0)/zoom;
        }
    mx0=mx1; my0=my1; sh0=sh1;
    gl_draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button,TShiftState Shift, int X, int Y)
    {
    FormMouseMove(Sender,Shift,X,Y);
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button,TShiftState Shift, int X, int Y)
    {
    FormMouseMove(Sender,Shift,X,Y);
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormMouseWheel(TObject *Sender, TShiftState Shift, int WheelDelta, TPoint &MousePos, bool &Handled)
    {
    if (WheelDelta>0) zoom*=1.2;
    if (WheelDelta<0) zoom/=1.2;
    Handled=true;
    gl_draw();
    }
//---------------------------------------------------------------------------
void __fastcall TForm1::FormKeyDown(TObject *Sender, WORD &Key, TShiftState Shift)
    {
    Caption=Key;
    if (Key==32){ _multi=!_multi; gl_draw(); }      // [Space]
    if (Key==33){ if (N<8192) N<<=1; gl_draw(); }   // [PgUp]
    if (Key==34){ if (N> 128) N>>=1; gl_draw(); }   // [PgDown]
    }
//---------------------------------------------------------------------------

这是单程分数转义n=100*32：

这是单通整数转义n=100：

正如您所见，对于相同的迭代次数（100），分数转义要好得多。

最后是漂亮的多遍（作为炫耀）仅256次迭代和~300倍缩放：

与单程相比：

关于修改的一些说明：

我将sh小数位部分添加到计数器（定点）。因此，最大计数现在是n

多通道仅在CPU端代码上更改。它只需重新索引使用过的索引，使其没有漏洞，并使用可见光谱颜色重新绘制索引。

此处演示：

  • Win32 C /GL/GLSLMandelbrot设置演示32位浮点（旧）
  • Win32 C /GL/GLSLMandelbrot设置演示64位浮点（新）
    •

 类似资料：
  • 朱莉娅·塞特和曼德尔布罗特·塞特是什么关系？

    我写了一个mandelbrot集，我读过关于julia集的文章，它非常相似，但到底是什么关系呢？我能用mandelbrot公式画一个julia集吗？起始参数是什么？请阅读我的mandelbrot集合代码： 我不确定mandelbrot集对于z是迭代的，julia集对于c是迭代的，这意味着什么？我需要更改代码吗？ 更新：我更改了代码，但它不起作用。我的想法是从$re和$im开始，而不是从0开始： 更

  • 我不能理解曼德布罗特分形代码的一些东西

    这是计算功能代码。我听说“逃跑”应该是。因为如果（）小于，它就不会无限大。但是在这个代码中，转义是。为什么？为什么？

  • 曼德布洛特(Mandelbrot)集合

    虽然可视化曼德布洛特(Mandelbrot)集合与机器学习没有任何关系，但这对于将TensorFlow应用在数学更广泛的领域是一个有趣的例子。实际上，这是tensorflow一个非常直截了当的可视化运用。（我们最终也许会提供一种更加精心设计的运用方式来生成真正更加美丽的图像。） 说明：本教程使用了IPython的notebook。 基本步骤 首先，我们需要导入一些库。 # 导入仿真库 import

  • 找不到格拉德尔·弗利特

    我通过VS Code创建了一个新的flutter项目。但是我不知道为什么我在运行时会有这个错误 失败：构建失败，有一个异常。 > 错误：配置根项目“android”时出现问题。 无法解析配置“：classpath”的所有项目。找不到com。Android工具。建造：梯度：3.6。2.在以下位置搜索： https://dl.google.com/dl/android/maven2/com/andro

  • 2.9 曼德布洛特(Mandelbrot)集合

    虽然可视化曼德布洛特(Mandelbrot)集合与机器学习没有任何关系，但这对于将TensorFlow应用在数学更广泛的领域是一个有趣的例子。实际上，这是tensorflow一个非常直截了当的可视化运用。（我们最终也许会提供一种更加精心设计的运用方式来生成真正更加美丽的图像。） 说明：本教程使用了IPython的notebook。 基本步骤 首先，我们需要导入一些库。 # 导入仿真库 import

  • intelliJ找不到特定的方法

    下面的代码中有一个编译错误，我不知道如何修复。 但我明白 错误：（8，14）java:找不到symbol symbol:方法readString（java.nio.file.Path） 位置：类java。尼奥。文件文件夹 有很多事情需要注意。 > 这只发生在。如果我尝试（java.nio.file.Files中的另一种方法），它可以工作 这段代码在intelliJ中不起作用，但在eclipse中起

相关问答

贝尔曼-福特算法贝尔曼-福特图算法我试图画曼德布罗特集时，我的数学出了什么问题？格雷德尔突然不建了。找不到Gradle DSL方法：'android()'是否有方法定义两种设置中使用的属性。格拉德尔。kts和项目/子项目构建。格拉德尔。带gradle 6.0的kts？

相关文章

iOS获取设备唯一标识的8种方法将一种测试方法的输出传递给另一种方法testng是否有一种方便的方法来创建谓词来测试字段是否等于给定值？Junit测试布尔方法在Apache WorkbookFactory上找不到close（）方法

相关阅读

整理分布式唯一ID的六种生成方案科曼医疗 算法工程师 一面宁德时代 项目管理 一面深圳科曼医疗设备有限公司 一面 算法测试Dart布尔类型

相关工具

一种用"知识点"来找人的搜人引擎舒尔特表俄罗斯方块cocos2d-x曼巴博客阿尔法 RPG

相关文档

各种算法的 Python 实现方案Effective C# 改善 C# 程序的 50 种方法23 种设计模式程序设计思想与方法写给不耐烦的 JavaScript 程序员
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.