相关疑难解决方法(0)

我需要一种算法或函数来将可见光谱范围的每个波长映射到其等效的RGB值.RGB系统和灯的波长之间是否存在任何结构关系？喜欢这个图像: 替代文字http://www1.appstate.edu/~kms/classes/psy3203/Color/spectrum5.gif 抱歉,如果这是无关紧要的: - ]

我正在尝试使用 HSV 值和 PIL 库为 MandelBrot 着色。

即使多次尝试摆弄 HSV 值，我也无法达到预期的效果。

这是我目前拥有的

这是想要的效果

这是我正在尝试的代码，如果您可以添加一些提示来优化下面的代码以更快地计算集合，这也可能是有益的，我是 python 新手

from PIL import Image
import random
import math
from decimal import Decimal


# Size of the Image Canvas
HEIGHT = 500

ZOOM = 0.0
Y_PAN = 0.0


# Range of the Complex Plane
MIN_X = -2.0 + ZOOM
MAX_X = 2.0 - ZOOM


MAX_Y = 2.0 + Y_PAN - ZOOM
MIN_Y = -2.0 + Y_PAN + ZOOM

DATA = []


def map_to_scale_d(x, in_min, in_max, out_min, …

有趣的Mandelbrot Set箍和卷发器是否是浮点计算结果不准确的结果？

我已经编写了各种Mandelbrot Set实现，例如动态缩放和回放。有些使用定点算法，另一些使用FPU。

我已经看到了这个问题，这表明每个芽在数学上都是光滑的形状，周围有较小的芽。

海马形状之类的游行是否是计算机浮点算术限制的副作用，而不是实际的Mandelbrot集的副作用？

海马？由Spektre添加：

我一直想说的是，浮点算术，无论是定点还是固定有效，都无法保持迭代步骤的真实结果。Mandelbrot集的有趣部分在边界附近，并且在该区域中，迭代坐标可以在最终“转义”之前以循环近重复的形式重复进行数千次迭代。

我的问题是：算术运算是否会以导致模式失败的方式失败？据我所知，完美的曼德布罗集实际上是形状光滑的芽，围绕其他芽无限地排列。评论者说，算术越好，著名的海马等形状就越好，如果实施不当会产生模糊的图像，就可以看出这一点。但这只会使我的问题更加棘手：算术越精确，算术就越失败，直到随着坐标的变化而出现不连续，并且以略有不同的方式发展为失败为止。

无论如何，这是一个C函数，它使用x87 FPU迭代一个点。该代码不是最近的代码，可以利用正方形之间的差异来改进它，这仍然存在于我的古老“待办事项”列表中。

int MAXRAD = 4;
int K_LIMIT = 5000;
double REAL8, IMAG8;

int iterate (void)
// calculate Mandelbrot iterations of REAL8, IMAG8
// return iterations
{
int iters;

    __asm {

        FILD    DWORD PTR MAXRAD       ;MAX R^2
        FLD     QWORD PTR IMAG8        ;INIT Y VALUE
        FLD     QWORD PTR REAL8        ;INIT X VALUE

        FLD     ST(1)     ;WORKING Y = IMAG
        FLD     ST(1)     ;WORKING X = REAL

        MOV     ECX,DWORD …

我用 python 编写了 Mandelbrot 集，但这看起来很奇怪，所以我寻找平滑的颜色。我已经使用对数和线性插值编写了一个平滑的着色函数，但无论我尝试什么，我都无法得到我想要的：

self.palette = [(3, 25, 61),(5, 43, 107),(7, 61, 153),(20, 96, 226),(20, 164, 226),(74, 181, 226),(138, 211, 242),(205, 234, 247),(225, 237, 242),(255,255,255)]

这是我的调色板

if n == self.max_iterations:
    self.screen.set_at((x, y), (110, 13, 13))
else:
    gradient = 1 + n - math.log(math.log(abs(m))) / math.log(2.0)
    iteration = n + 1 - gradient
    color1 = list(self.palette[n % 10])
    if n % 10 <= 8:
        color2 = list(self.palette[n % 10+1])
    else:
        color2 = list(self.palette[-1])

    color = [[], [], []]
    for number, …

我正在使用 OpenGL 使用 C++ 对 Mandelbrotset 进行编程，但遇到了一个问题：我发送到着色器并在着色器中计算的浮点数只能容纳一定数量的小数位。因此，如果我放大得太远，它就会变得像素化。

我想过创建自定义数组函数，但我无法真正弄清楚。除了使用数组还有其他方法吗？如果不是，我如何使用数组来计算东西，就好像它们是单个数字一样？（例如 arr[1,2] x arr[0,2] 应该给出与仅计算 1.2 x 0.2 相同的输出）

in vec4 gl_FragCoord;
 
out vec4 frag_color;
uniform float zoom;
uniform float x;
uniform float y;
#define maximum_iterations 1000

int mandelbrot_iterations()
{
    float real = ((gl_FragCoord.x / 1440.0f - 0.5f) * zoom + x) * 4.0f;
    float imag = ((gl_FragCoord.y / 1440.0f - 0.5f) * zoom + y) * 4.0f;
 
    int iterations = 0;
    float const_real = real;
    float const_imag = imag;
 
    
    while (iterations < …

我尝试了许多用于渲染曼德尔布罗特集的算法，包括朴素的逃逸时间算法，以及优化的逃逸时间算法。但是，是否有更快的算法可以像我们在 YouTube 上看到的那样有效地产生真正深度的缩放。另外，我很想了解一些关于如何提高 C/C++ 之外的精度的想法 double

我正在编写一个用 C 语言绘制 Mandelbrot 集的程序。我已经能够显示它并且看起来不错，但是当我减少迭代次数时，我得到了这种效果，生成了我只能描述为“云”的效果：

它应该是这样的（我从网站上得到的）：

。

我怎样才能让我的看起来像上面的那样？这是绘制单个点的代码：

double getFracPoint(double x,double y){

    //scale x and y
    x = x * ((plotEnd.x-plotStart.x) / SCREENWIDTH) + plotStart.x;
    y = y * ((plotEnd.y-plotStart.y) / SCREENHEIGHT) + plotStart.y;

    x/=zoom;
    y/=zoom;

    //instead of using the complex number library of the C standard
    //I decided to use regular numbers as it turns out to be faster.

    //The first number is the real part the second number is the imaginary
    //part.
    double z[2];
    z[0] = z[1] = …

确实存在所谓的超操作序列。它的工作原理就像你a*b=a+a+a+a...+a用许多a重复b次数的加法来构造乘法。然后a^b = a*a*a*a*...*a进行a多次重复乘法的幂运算b。然后，出现tetration，表示为幂的塔，就像a^^b == a^a^a^...^a，重复b次数。

我对如何为浮点数和复数编写此函数感兴趣？

我已经在 glsl 中编写了乘法和幂函数：

// complex multiplication:
vec2 cmul(in vec2 a, in vec2 b) {
    return vec2(a.x*b.x-a.y*b.y, a.x*b.y+a.y*b.x);
}

// complex exponent e^a
vec2 cexp(in vec2 a) {
    float ea = exp(a.x);
    float vl = a.y;
    return ea * vec2( cos(vl), sin(vl) );
}

// complex natural logarithm ln(a)
vec2 cln(in vec2 a) {
    float …