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

Question

Я знаю, что на вопрос об этом много вопросов. Однако моя незначительно меняется. Всякий раз, когда я реализую алгоритм гладкой раскраски, насколько я понимаю.

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

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

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

Я вычисляю множество рекурсивно, а в другой функции (не размещенной ниже) я устанавливаю ширину и высоту окна, а затем повторяю их для пикселей окна 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 до (excl) 1, тогда вы просто используете (int) (значение * 256)