一、说明

        到目前为止，在我们的讨论中，我已经交替使用了“傅里叶变换”和“快速傅里叶变换（FFT）”。在这一点上，值得注意的是区别！FFT 是“离散”傅里叶变换 （DFT） 的有效算法实现。“离散”表示我们可以将变换应用于一系列点，而不是完整的连续信号。在数据科学应用中，我们通常有一组样本，而不是一个连续的输入函数，所以我们通常对DFT感兴趣！

# see full context at https://github.com/peterbbryan/fourier-sketcher

@staticmethod
def _from_jpeg(path_str: str) -> Image:
    """ Load image at path. """

    return Image.open(path_str)

@property
def binary_mask(self):
    """ Binary mask from image. """

    im = np.array(self._image)  # pylint: disable=invalid-name
    edges = cv.Canny(im, 100, 150)  # pylint:disable=no-member

    return np.array(edges).astype(np.bool)

# see full context at https://github.com/peterbbryan/fourier-sketcher

@property
def complex_sequence(self) -> np.ndarray:
    """ Binary pixel coordinates as complex sequence. """

    # row/col to x/y will impart a directional flip on coordinates
    locs = np.argwhere(np.flipud(self.binary_mask)).astype(np.complex128)
    n_rows, n_cols = self.binary_mask.shape

    # center about the origin
    rows = locs[:, 0] - (n_rows // 2)
    columns = locs[:, 1] - (n_cols // 2)

    # represent y values with i
    rows *= 1j

    # restructure to x, y order
    return rows + columns

# see full context at https://github.com/peterbbryan/fourier-sketcher

@staticmethod
def _sort_points(
    complex_sequence: np.ndarray, stopping_threshold: float = 10
) -> np.ndarray:
    """
    Arrange points so that neighbors are near each other in sequence.
    Args:
        complex_sequence: Points as complex array.
    Returns:
        Sorted points to minimize sequential differences.
    """

    reordered: List[np.complex128] = []
    current_point = complex_sequence[0]
    complex_sequence[0] = np.inf

    while len(reordered) < complex_sequence.shape[0]:

        if np.min(np.abs(complex_sequence - current_point)) > stopping_threshold:
            break

        min_dist_ind = np.argmin(np.abs(complex_sequence - current_point))
        reordered.append(current_point)
        current_point = complex_sequence[min_dist_ind]
        complex_sequence[min_dist_ind] = np.inf

    return np.array(reordered)

# see full context at https://github.com/peterbbryan/fourier-sketcher

def _get_frequency_components(self) -> Tuple[np.ndarray, np.ndarray]:
    """
    Get frequency components from outline.
    Returns:
        Tuple of frequency values and bin centers.
    """

    complex_sequence = self._sort_points(self._edger.complex_sequence)

    fft_values = np.fft.fft(complex_sequence)
    fft_bins = np.fft.fftfreq(len(fft_values), d=1 / (len(fft_values)))

    # make this less stupid
    fft_values = fft_values[np.abs(fft_bins) <= (self._n_oscillators / 2)]
    fft_bins = fft_bins[np.abs(fft_bins) <= (self._n_oscillators / 2)]

    fft_bins = fft_bins[np.argsort(-np.abs(fft_values))]
    fft_values = fft_values[np.argsort(-np.abs(fft_values))]

    return fft_values, fft_bins

# see full context at https://github.com/peterbbryan/fourier-sketcher

def _get_arr_from_fig(self, dpi: int = 90) -> np.ndarray:
    """
    Get np.ndarray from a figure.
    Args:
        fig: Matplotlib Figure.
        dpi: Resolution.
    Returns:
        Numpy array of image contents.
    """

    buf = io.BytesIO()
    self._fig.savefig(buf, format="png", dpi=dpi)
    buf.seek(0)
    img_arr = np.frombuffer(buf.getvalue(), dtype=np.uint8)
    buf.close()
    img = cv2.imdecode(img_arr, 1)  # pylint: disable=no-member
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # pylint: disable=no-member

    return img
  
@staticmethod
def _make_plot(points: List[Tuple[float, float]]) -> None:
    """
    Plot outline so far.
    Args:
        points: x, y points to plot.
    """

    plt.scatter(*list(zip(*points)), linewidth=1)

    plt.draw()
    plt.axis("square")
    plt.axis("off")
    
def make_gif(self, path_str: str) -> None:
    """
    Make gif of outline.
    Args:
        path_str: Path to write gif to.
    """

    plt.ion()

    fft_values, fft_bins = self._get_frequency_components()
    plots, points = [], []

    for step in tqdm.tqdm(np.linspace(0, 2 * np.pi, self._n_steps)):

        edge = (0.0, 0.0)

        for i in range(self._n_oscillators):

            mag = np.abs(fft_values[i])
            ang = np.angle(fft_values[i])

            oscillator = self._get_oscillator(frequency=fft_bins[i], phase=ang)
            circle = self._get_circle(
                center=edge, radius=mag, angle=oscillator.angle(step)
            )
            circle.draw()
            edge = circle.edge_point

            if i == self._n_oscillators - 1:
                points.append(edge)

        self._make_plot(points)

        plot_img_np = self._get_arr_from_fig()
        plots.append(Image.fromarray(plot_img_np))

        plt.clf()

    self._write_gif(plots, path_str)

# see full context at https://github.com/peterbbryan/fourier-sketcher

@staticmethod
def _write_gif(
    plots: List[Image.Image],
    path_str: str,
    last_frame_repeats: int = 100,
    duration: int = 60,
) -> None:
    """
    Write animated gif.
    Args:
        plots: Output plots to write.
        path_str: Path to output gif.
        last_frame_repeats: Number of repeats of last still.
        duration: Duration in seconds.
    """

    for _ in range(last_frame_repeats):
        plots.append(plots[-1])

    plots[0].save(
        path_str, save_all=True, append_images=plots[1:], duration=duration, loop=0,
    )