如何制作mandelbrot分形缩放（Python）的gif？

Question

我在Python中使用PIL模块制作了一个Mandelbrot分形。现在，我想做一个放大到一点的GIF。我在网上看过其他代码，但不用说，我不明白，因为我使用的模式有点不同（我使用的是类）。

我知道要放大我需要改变比例。。。但我显然不知道如何实施它。

from PIL import Image
import random


class Fractal:
    """Fractal class."""

    def __init__(self, size, scale, computation):
        """Constructor.

        Arguments:
        size -- the size of the image as a tuple (x, y)
        scale -- the scale of x and y as a list of 2-tuple
                 [(minimum_x, minimum_y), (maximum_x, maximum_y)]
        computation -- the function used for computing pixel values as a function
        """
        self.size = size
        self.scale = scale
        self.computation = computation
        self.img = Image.new("RGB", (size[0], size[1]))

    def compute(self):
        """
        Create the fractal by computing every pixel value.
        """
        for y in range(self.size[1]):
            for x in range(self.size[0]):
                i = self.pixel_value((x, y))
                r = i % 8 * 32
                g = i % 16 * 16
                b = i % 32 * 8
                self.img.putpixel((x, y), (r, g, b))

    def pixel_value(self, pixel):
        """
        Return the number of iterations it took for the pixel to go out of bounds.

        Arguments:
        pixel -- the pixel coordinate (x, y)

        Returns:
        the number of iterations of computation it took to go out of bounds as integer.
        """
        # x = pixel[0] * (self.scale[1][0] - self.scale[0][0]) / self.size[0] + self.scale[0][0]
        # y = pixel[1] * (self.scale[1][1] - self.scale[0][1]) / self.size[1] + self.scale[0][1]
        x = (pixel[0] / self.size[0]) * (self.scale[1][0] - self.scale[0][0]) + self.scale[0][0]
        y = (pixel[1] / self.size[1]) * (self.scale[1][1] - self.scale[0][1]) + self.scale[0][1]

        return self.computation((x, y))

    def save_image(self, filename):
        """
        Save the image to hard drive.

        Arguments:
        filename -- the file name to save the file to as a string.
        """
        self.img.save(filename, "PNG")

if __name__ == "__main__":
    def mandelbrot_computation(pixel):
        """Return integer -> how many iterations it takes for the pixel to escape the mandelbrot set."""
        c = complex(pixel[0], pixel[1])  # Complex number: A + Bi  (A is real number, B is imaginary number).
        z = 0  # We are assuming the starting z value for each square is 0.
        iterations = 0  # Will count how many iterations it takes for a pixel to escape the mandelbrot set.

        for i in range(255):  # The more iterations, the more detailed the mandelbrot set will be.
            if abs(z) >= 2.0:  # Checks, if pixel escapes the mandelbrot set. Same as square root of pix[0] and pix[1].
                break
            z = z**2 + c
            iterations += 1

        return iterations

    mandelbrot = Fractal((1000, 1000), [(-2, -2), (2, 2)], mandelbrot_computation())
    mandelbrot.compute()
    mandelbrot.save_image("mandelbrot.png")

Answer 1

这是一个“简单”的线性变换，包括缩放（缩放）和平移（平移），正如您在线性代数中所学的那样。你记得这样的公式吗

s(y-k) = r(x-h) + c

翻译是（h， k）；每个方向的刻度是（r， s）。

要实现这一点，您需要更改循环增量。要在每个方向上放大系数k，需要缩小坐标范围，同样减少像素位置之间的增量。

这里最重要的是将显示坐标与数学值部分解耦：不再在标记为（0.2，-0.5）的位置显示0.2-0.5i的值；新位置根据新帧边界计算。

你的旧代码不太适合这个：

    for y in range(self.size[1]):
        for x in range(self.size[0]):
            i = self.pixel_value((x, y))
            ...
            self.img.putpixel((x, y), (r, g, b))

相反，你需要这样的东西：

    # Assume that the limits x_min, x_max, y_min, y_max
    #   are assigned by the zoom operation.
    x_inc = (x_max - x_min) / self.size[0]
    y_inc = (y_max - y_min) / self.size[1]
    for y in range(self.size[1]):
        for x in range(self.size[0]):
            a = x*x_inc + x_min
            b = y*y_inc + y_min
            i = self.pixel_value((a, b))
            ...
            self.img.putpixel((x, y), (r, g, b))