Алгоритм гладкой раскраски для множества Мандельброта

Question

Я знаю, что Алради ответил на множество вопросов. Тем не менее, мой меняется немного. Всякий раз, когда мы реализуем алгоритм гладкой раскраски, как я понимаю.

mu = 1 + n + math.log2(math.log2(z))  / math.log2(2)

где n - итерация побега, а 2 - степень z, и, если я не ошибаюсь, z - модуль комплексного числа на этой итерации. Затем мы используем это перенормированное значение escape в нашей линейной интерполяции между цветами, чтобы получить гладко полосатый набор Мандельброта. Я видел ответы на другие вопросы об этом, где мы запускаем это значение через преобразование HSB в RGB, однако я все еще не понимаю, как это обеспечит плавный градиент цветов и как реализовать это в python.

Тем не менее, всякий раз, когда я пытался реализовать это, он генерирует значения RGB с плавающей запятой, но я не знаю ни одного формата изображения, кроме файла.tiff, который бы поддерживал это, и если мы округляем до целых чисел, у нас все еще остается негладкое полосатость. Так, как это должно произвести изображение с гладкой полосой, если мы не можем непосредственно использовать значения RGB, которые это производит? Пример кода из того, что я попробовал ниже, так как я не в полной мере понимаю, как реализовать это, я попытался найти решение, которое в некоторой степени дает плавные полосы. В результате получается несколько плавно сглаженное изображение между двумя цветами - синим для полного набора и постепенно белее - чем дальше мы увеличиваем масштаб изображения до точки, где на определенной глубине все кажется размытым. Поскольку для этого я использую tkinter, мне пришлось преобразовать значения RGB в шестнадцатеричные значения, чтобы их можно было нарисовать на холсте.

Я вычисляю набор рекурсивно, и в своей другой функции (не опубликованной ниже) я устанавливаю ширину и высоту окна, затем перебираю их для пикселей окна tkinter и вычисляю эту рекурсию во внутреннем цикле.

def linear_interp(self, color_1, color_2, i):

    r = (color_1[0] * (1 - i)) + (color_2[0] * i)
    g = (color_1[1] * (1 - i)) + (color_2[1] * i)
    b = (color_1[2] * (1 - i)) + (color_2[2] * i)
    rgb_list = [r, g, b]
    for value in rgb_list:
        if value > MAX_COLOR:
            rgb_list[rgb_list.index(value)] = MAX_COLOR
        if value < 0:
            rgb_list[rgb_list.index(value)] = abs(value)

    return (int(rgb_list[0]), int(rgb_list[1]), 
            int(rgb_list[2]))

def rgb_to_hex(self, color):
    return "#%02x%02x%02x" % color

def mandel(self, x, y, z, iteration):
    bmin = 100
    bmax = 255
    power_z = 2

    mod_z = math.sqrt((z.real * z.real) + (z.imag * z.imag))
    #If its not in the set or we have reached the maximum depth
    if  abs(z) >= float(power_z) or iteration == DEPTH:
        z = z
        if iteration > 255:
            factor = (iteration / DEPTH) * 255
        else:
            factor = iteration

        logs = math.log2(math.log2(abs(z) + 1 ) / math.log2(power_z))
        r = g = math.floor(factor + 5 - logs)

        b = bmin + (bmax - bmin) * r / 255
        rgb = (abs(r), abs(g), abs(round(b)))
        self.canvas.create_line(x, y, x + 1, y + 1,
                                fill = self.rgb_to_hex(rgb))

    else:

        z = (z * z) + self.c
        self.mandel(x, y, z, iteration + 1)

    return z

Answer 1

Разница между цветами #000000, #010000, ..., #FE0000, #FF0000 настолько мала, что вы получаете плавный градиент от черного к красному. Следовательно, просто округлите свои значения: предположим, что ваши сглаженные значения цвета вашей функции сглаживания находятся в диапазоне от 0 до (исключая) 1, затем вы просто используете (int) (значение * 256)