PMAE 1 : n-sided regular polygon

Python Matplotlib Animation Example 1

n-sided regular polygon

This Python code employs the Matplotlib library to produce an animated plot illustrating the construction and rotation of an n-sided regular polygon. The polygon evolves over time, gradually connecting points on a circle to create the desired shape. The animation is orchestrated through the draw function, which calculates the angle based on the elapsed time and updates the plot accordingly. By adjusting the argument in the getdata function, users can modify the number of sides, allowing for customization such as generating a hexagon by using getdata(6). The code provides a versatile and visually engaging tool for exploring different polygon shapes and animation speeds, making it a valuable resource for interactive visualization and experimentation.

This code animates an n-sided regular polygon rotating smoothly at a constant speed. You can adjust the number of sides (n) and animation speed (P) to explore different shapes and behaviors. The code uses efficient trigonometric calculations for point generation. Overall, it effectively generates and animates an n-sided polygon, providing a visualization of its rotation in a circle.

Python source code

import time import matplotlib.pyplot as plt import matplotlib.animation as animation from math import cos, sin, tan, pi fig = plt.figure(figsize=(3,3), facecolor="#FFFFFF") ax = plt.axes([0, 0, 1, 1]) ax.set_xlim([-1.2, 1.2]) ax.set_ylim([-1.2, 1.2]) ax.axis('off') def getdata(n): nth = 361 dth = 2*pi/(nth-1) sth = 2*pi/n xs, ys = [], [] for ith in range(nth): theta = ith*dth rth = int(theta/sth)*sth x1 = cos(sth/2) y1 = tan(sth/2-(theta-rth))*x1 x2 = x1*cos(rth) + y1*sin(rth) y2 = -x1*sin(rth) + y1*cos(rth) xs.append(x2) ys.append(y2) return xs, ys pl = ax.plot([], [], color="#0000FF")[0] xs, ys = getdata(8) def update(theta): ith = int(theta/(2*pi/(len(xs)-1))) pl.set_data(xs[0:ith], ys[0:ith]) def draw(i): P = 5.0 t = time.time() theta = t/P*2*pi%(2*pi) update(theta) ani = animation.FuncAnimation(fig, draw, interval=40) plt.show()

Summary:

This Python code generates and animates an n-sided regular polygon, where `n` is specified as an input value. It employs mathematical calculations, matplotlib, and animation functionalities to achieve this.

Code Breakdown:

■  Imports:
   • `time`: Used for timing the animation.
   • `matplotlib.pyplot as plt`: Provides plotting functions.
   • `matplotlib.animation as animation`: Used for creating the animation.
   • `math`: Provides mathematical functions like `cos`, `sin`, `tan`, and `pi`.

■  Figure and Axis Setup:
   • A figure with a fixed size of 300x300 and white background is created.
   • An axis is added within the figure, setting the x and y limits to [-1.2, 1.2] and turning off the axis labels and ticks.

■  `getdata` Function:
   • Takes `n` (the number of sides) as input.
   • Initializes `nth` to 361 (number of points to create) and `dth` to the angular distance between points based on `n`.
   • Calculates the step angle `sth` between vertices of the polygon.
   • Creates empty lists `xs` and `ys` to store x and y coordinates of points.
   • Iterates `nth` times to generate points:
     • Calculates the current angle `theta`.
     • Rounds `theta` down to the nearest multiple of `sth` using `int(theta/sth)*sth`.
     • Calculates intermediate values `x1` and `y1` based on `sth` and `theta`.
     • Rotates the point by `rth` using `x2` and `y2`.
     • Appends the point's coordinates to `xs` and `ys`.
   • Returns `xs` and `ys`.

■  Line Plot Setup:
   • Creates an empty line plot with a blue color in the axis.

■  Data Generation:
   • Calls `getdata(8)` to get data for an 8-sided polygon and stores the points in `xs` and `ys`.

■  `update` Function:
   • Takes a `theta` value as input.
   • Calculates the index `ith` of the point corresponding to `theta` based on the angular distance between points and the number of points.
   • Updates the line plot data using `pl.set_data(xs[0:ith], ys[0:ith])`, showing only points up to `ith`.

■  `draw` Function:
   • Takes a frame number `i` as input (not used in this code).
   • Sets a period `P` for the animation (5.0 seconds).
   • Calculates the current time `t`.
   • Calculates the animation angle `theta` based on `t`, `P`, and a 2*pi factor to ensure a full rotation within `P`.
   • Calls `update(theta)` to update the line plot data.

■  Animation Creation:
   • Creates an animation using `animation.FuncAnimation`.
   • Sets the animation function to `draw`.
   • Sets the update interval to 40 milliseconds.

■  Displaying the Animation:
   • Calls `plt.show()` to display the animation.

Key Points:

○ The animation creates a rotating polygon with `n` sides.
○ The animation speed is controlled by the `P` value in the `draw` function.
○ The code can be modified to change the number of sides, animation speed, and other parameters.