annoviko / pyclustering

    def __get_start_stop_iterations(self, start_iteration, stop_iteration):

        """!

        @brief Aplly rules for start_iteration and stop_iteration parameters.

        @param[in] start_iteration (uint): The first iteration that is used for calculation.

        @param[in] stop_iteration (uint): The last iteration that is used for calculation.

        @return (tuple) New the first iteration and the last.

        """

        if (start_iteration is None):

            start_iteration = len(self) - 1;

        if (stop_iteration is None):

            stop_iteration = start_iteration + 1;

        return (start_iteration, stop_iteration);

class sync_visualizer:

    """!

    @brief Visualizer of output dynamic of sync network (Sync).

    """

    @staticmethod

    def show_output_dynamic(sync_output_dynamic):

        """!

        @brief Shows output dynamic (output of each oscillator) during simulation.

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

        @see show_output_dynamics

        """

        draw_dynamics(sync_output_dynamic.time, sync_output_dynamic.output, x_title = "t", y_title = "phase", y_lim = [0, 2 * 3.14]);

    @staticmethod

        return sequence_order;

    def calculate_local_order_parameter(self, oscillatory_network, start_iteration = None, stop_iteration = None):

        """!

        @brief Calculates local order parameter.

        @details Local order parameter or so-called level of local or partial synchronization is calculated by following expression:

        \f[

        r_{c}=\left | \sum_{i=0}^{N} \frac{1}{N_{i}} \sum_{j=0}e^{ \theta_{j} - \theta_{i} } \right |;

        \f]

        where N - total amount of oscillators in the network and \f$N_{i}\f$ - amount of neighbors of oscillator with index \f$i\f$.

        @param[in] oscillatory_network (sync): Sync oscillatory network whose structure of connections is required for calculation.

        @param[in] start_iteration (uint): The first iteration that is used for calculation, if 'None' then the last iteration is used.

        @param[in] stop_iteration (uint): The last iteration that is used for calculation, if 'None' then 'start_iteration' + 1 is used.

        @return (list) List of levels of local (partial) synchronization (local order parameter evolution).

        """

        (start_iteration, stop_iteration) = self.__get_start_stop_iterations(start_iteration, stop_iteration);

        if (self._ccore_sync_dynamic_pointer is not None):

            network_pointer = oscillatory_network._ccore_network_pointer;

            return wrapper.sync_dynamic_calculate_local_order(self._ccore_sync_dynamic_pointer, network_pointer, start_iteration, stop_iteration);

        sequence_local_order = [];

        for index in range(start_iteration, stop_iteration):

            sequence_local_order.append(order_estimator.calculate_local_sync_order(self.output[index], oscillatory_network));

        return sequence_local_order;

    def __get_start_stop_iterations(self, start_iteration, stop_iteration):

        """!

        @brief Aplly rules for start_iteration and stop_iteration parameters.

        return default_value;

    @staticmethod

    def animate_cluster_allocation(data, observer, animation_velocity = 500, movie_fps = 1, save_movie = None):

        """!

        @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();