annoviko / pyclustering

        @brief Animates clustering process that is performed by K-Means algorithm.

        @param[in] data (list): Dataset that is used for clustering.

        @param[in] observer (kmeans_observer): EM observer that was used for collection information about clustering process.

        @param[in] animation_velocity (uint): Interval between frames in milliseconds (for run-time animation only).

        @param[in] movie_fps (uint): Defines frames per second (for rendering movie only).

        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.

        """

        figure = plt.figure();

        def init_frame():

            return frame_generation(0);

        def frame_generation(index_iteration):

            figure.clf();

            figure.suptitle("K-Means algorithm (iteration: " + str(index_iteration) + ")", fontsize=18, fontweight='bold');

            clusters = observer.get_clusters(index_iteration);

            centers = observer.get_centers(index_iteration);

            kmeans_visualizer.show_clusters(data, clusters, centers, None, figure=figure, display=False);

            figure.subplots_adjust(top=0.85);

            return [figure.gca()];

        iterations = len(observer);

        cluster_animation = animation.FuncAnimation(figure, frame_generation, iterations, interval=animation_velocity,

                                                    init_func=init_frame, repeat_delay=5000);

        if save_movie is not None:

            cluster_animation.save(save_movie, writer='ffmpeg', fps=movie_fps, bitrate=3000);

        else:

            plt.show();

class kmeans:

    """!

    @brief Class represents K-Means clustering algorithm.

    @details CCORE option can be used to use the pyclustering core - C/C++ shared library for processing that significantly increases performance.

    CCORE implementation of the algorithm uses thread pool to parallelize the clustering process.

            plt.show();

    @staticmethod

    def animate_phase_matrix(sync_output_dynamic, grid_width = None, grid_height = None, animation_velocity = 75, colormap = 'jet', save_movie = None):

        """!

        @brief Shows animation of phase matrix between oscillators during simulation on 2D stage.

        @details If grid_width or grid_height are not specified than phase matrix size will by calculated automatically by square root.

        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.

        @param[in] grid_width (uint): Width of the phase matrix.

        @param[in] grid_height (uint): Height of the phase matrix.

        @param[in] animation_velocity (uint): Interval between frames in milliseconds.

        @param[in] colormap (string): Name of colormap that is used by matplotlib ('gray', 'pink', 'cool', spring', etc.).

        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.

        """

        figure = plt.figure();

        def init_frame(): 

            return frame_generation(0);

        def frame_generation(index_dynamic):

            figure.clf();

            axis = figure.add_subplot(111);

            phase_matrix = sync_output_dynamic.allocate_phase_matrix(grid_width, grid_height, index_dynamic);

            axis.imshow(phase_matrix, cmap = plt.get_cmap(colormap), interpolation='kaiser', vmin = 0.0, vmax = 2.0 * math.pi);

            artist = figure.gca();

            return [ artist ];

        phase_animation = animation.FuncAnimation(figure, frame_generation, len(sync_output_dynamic), init_func = init_frame, interval = animation_velocity , repeat_delay = 1000);

        if (save_movie is not None):

            phase_animation.save(save_movie, writer = 'ffmpeg', fps = 15, bitrate = 1500);

        else:

            plt.show();

    @staticmethod

            plt.show();

    @staticmethod

    def animate_correlation_matrix(sync_output_dynamic, animation_velocity = 75, colormap = 'cool', save_movie = None):

        """!

        @brief Shows animation of correlation matrix between oscillators during simulation.

        @param[in] sync_output_dynamic (sync_dynamic): Output dynamic of the Sync network.

        @param[in] animation_velocity (uint): Interval between frames in milliseconds.

        @param[in] colormap (string): Name of colormap that is used by matplotlib ('gray', 'pink', 'cool', spring', etc.).

        @param[in] save_movie (string): If it is specified then animation will be stored to file that is specified in this parameter.

        """

        figure = plt.figure();

        correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(0);

        artist = plt.imshow(correlation_matrix, cmap = plt.get_cmap(colormap), interpolation='kaiser', hold = True, vmin = 0.0, vmax = 1.0);

        def init_frame(): 

            return [ artist ];

        def frame_generation(index_dynamic):

            correlation_matrix = sync_output_dynamic.allocate_correlation_matrix(index_dynamic);

            artist.set_data(correlation_matrix);

            return [ artist ];

        correlation_animation = animation.FuncAnimation(figure, frame_generation, len(sync_output_dynamic), init_func = init_frame, interval = animation_velocity , repeat_delay = 1000, blit = True);

        if (save_movie is not None):

            correlation_animation.save(save_movie, writer = 'ffmpeg', fps = 15, bitrate = 1500);

        else:

            plt.show();

    @staticmethod