mathplotlib on Software Development Notes

Three Dimensional Shapes and Shading

Eric Callanan — Sunday, 24 Jan 2021

Three dimensional objects are not easy to represent on a 2D surface such as a page or screen. In this article, inspired by chapter 3 of Math for Programmers book, we look at the cross product of two 3D-vectors and representing the surface of any 3D object as a collection of triangles. The cross product can be used to determine the direction of a triangle and this can be used to determine if the triangle is visible and the level of shading.

These are my notes on the book Math for Programmers by Paul Orland.

2D vectors and vector arithmetic
Two Dimensional shapes
Three Dimensional Vectors and Dot Product
Three Dimensional Shapes and Shading

Cross product

The cross product of two vectors v and u (v × u), is a vector that is perpendicular to both v and u, and therefore normal to the plane containing them. The magnitude of the cross product vector equals the area of a parallelogram with the vectors for sides. The direction of the vector of the cross product obeys the right-hand rule.

The orientation of the three axes in three-dimensional space can have two possible orientations. The right-hand rule is a common mnemonic for understanding orientation of axes in three-dimensional space. One can see this by pointing the right index finger along the positive x-axis and curl the remaining fingers toward the positive y-axis, the thumb tells you the direction of the positive z-axis.

The formula to calculate the cross product seems a little complex at first. It is easy to write a python function to calculate the cross product.

$$ \begin{gathered} vector \ u = (u_x, \ u_y, \ u_z) \\\ vector \ v = (v_x, \ v_y, \ v_z) \end{gathered} $$

$$ u \ {\times} \ v = (u_yv_z - u_zv_y, \ u_zv_x - u_xv_z , \ u_xv_y - u_yv_x) $$

Adding color to the x,y,z coordinates makes it easier to see that the resultant coordinate is made from the difference of the products of the other two coordinates. For example the cross product x coordinate is the difference of the y*z and z*y of the vectors. Note that cross product is noncommutative in that u x v is not equal to v x u.

$$ vector \ u = (u_{\color{aqua}x}, \ u_{\color{fuchsia}y}, \ u_{\color{olive}z}), \\\ vector \ v = (v_{\color{aqua}x}, \ v_{\color{fuchsia}y}, \ v_{\color{olive}z}) $$

$$ u \ {\times} \ v = (u_{\color{fuchsia}y}v_{\color{olive}z} - u_{\color{olive}z}v_{\color{fuchsia}y}, \ u_{\color{olive}z}v_{\color{aqua}x} - u_{\color{aqua}x}v_{\color{olive}z} , \ u_{\color{aqua}x}v_{\color{fuchsia}y} - u_{\color{fuchsia}y}v_{\color{aqua}x}) $$

$$ u \ {\times} \ v \neq v \ {\times} \ u $$

 1def cross(u, v):
 2    ux,uy,uz = u
 3    vx,vy,vz = v
 4    return (uy*vz - uz*vy, uz*vx - ux*vz, ux*vy - uy*vx)
 5
 6print(cross((3, 4, 5), (4, 4, 4)))
 7print(cross((4, 4, 4), (3, 4, 5)))
 8
 9"""
10(-4, 8, -4)
11(4, -8, 4)
12"""

 1def plot_axes(ax):
 2    ax.plot((-4, 4), (0, 0), (0, 0), color="grey")
 3    ax.plot((0, 0), (-4, 4), (0, 0), color="grey")
 4    ax.plot((0, 0), (0, 0), (-4, 4), color="grey")
 5
 6
 7def plot_vector(ax, v, c):
 8    ax.plot((0, v[0]), (0, v[1]), (0, v[2]), color=c)
 9
10
11def update_axis(ax, v1, v2):
12    plot_axes(ax)
13    plot_vector(ax, v1, "blue")
14    plot_vector(ax, v2, "red")
15    vx = cross(v1, v2)
16    plot_vector(ax, vx, "cyan")
17    ax.set_title(f"\n{v1} x {v2} \ncross product = {vx}", fontsize=10)
18
19
20fig, axs = plt.subplots(
21    2, 3, figsize=(10, 8), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
22)
23fig.suptitle(
24    f"Cross product of two 3D-vectors",
25    fontsize=18,
26    fontweight="bold",
27)
28
29for i, ax in enumerate(axs.flatten()):
30    ax.set_facecolor(plt.cm.Blues(0.1))
31    ax.set_xlim(-7, 5)
32    ax.set_ylim(-5, 5)
33    ax.set_zlim(-6, 10)
34    ax.set_xlabel("x-axis")
35    ax.set_ylabel("y-axis")
36    ax.set_zlabel("z-axis")
37
38u = (3, 4, 5)
39v = (4, 4, 4)
40update_axis(axs[0][0], u, v)
41update_axis(axs[0][1], v, u)
42update_axis(axs[1][0], u, v)
43update_axis(axs[1][1], v, u)
44
45u = (2, 2, 0)
46v = (0, 4, 0)
47update_axis(axs[0][2], u, v)
48update_axis(axs[1][2], v, u)
49
50for ax in [axs[1][0], axs[1][1], axs[1][2]]:
51    ax.view_init(azim=-80)
52
53fig.tight_layout(pad=2.0)
54plt.show()

Cross product of two 3D vectors

Cross product of 3D vectors viewed from two angles

Length of Cross Product

The magnitude (length) of the cross product is equal to the area of the parallelogram formed by the two vectors. The cross product of parallel vectors is zero as is the cross product of opposite vectors. The magnitude of the cross product of two vectors is at a maximum when those vectors are at 90⁰ to each other.

 1def plot_axes(ax):
 2    ax.plot((-4, 4), (0, 0), (0, 0), color="grey")
 3    ax.plot((0, 0), (-4, 4), (0, 0), color="grey")
 4    ax.plot((0, 0), (0, 0), (-4, 4), color="grey")
 5
 6
 7def plot_vector(ax, v, c):
 8    ax.plot((0, v[0]), (0, v[1]), (0, v[2]), color=c)
 9
10
11def update_axis(ax, v1, v2):
12    plot_axes(ax)
13    plot_vector(ax, v1, "blue")
14    plot_vector(ax, v2, "red")
15    vx = cross(v1, v2)
16    plot_vector(ax, vx, "cyan")
17    ax.set_title(
18        f"\n{v1} x {v2} \nlength cross product = {vector_length(vx):.1F}", fontsize=10
19    )
20
21
22fig, axs = plt.subplots(
23    2, 3, figsize=(10, 8), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
24)
25fig.suptitle(
26    f"Length of cross product of two 3D-vectors",
27    fontsize=18,
28    fontweight="bold",
29)
30
31for i, ax in enumerate(axs.flatten()):
32    ax.set_facecolor(plt.cm.Blues(0.1))
33    ax.set_xlim(-7, 5)
34    ax.set_ylim(-5, 5)
35    ax.set_zlim(-6, 10)
36    ax.set_xlabel("x-axis")
37    ax.set_ylabel("y-axis")
38    ax.set_zlabel("z-axis")
39
40update_axis(axs[0][0], (3, 0, 0), (3, 0, 0))
41update_axis(axs[0][1], (3, 0, 0), (2, 2, 0))
42update_axis(axs[0][2], (3, 0, 0), (1, 3, 0))
43update_axis(axs[1][0], (3, 0, 0), (0, 3, 0))
44update_axis(axs[1][1], (3, 0, 0), (-2, 2, 0))
45update_axis(axs[1][2], (3, 0, 0), (-3, 0, 0))
46
47plt.show()
48
49publish_png_image(fig, "length-of-cross-product-3d-vector.png")

Length of cross product is equal to parallelogram area

Length of cross product is equal to parallelogram area

Triangle composed of 3 vectors

A triangle is composed of three sides or three vectors. Each vector is composed of two sets of coordinates, a start and an end. To form a triangle the three vectors must be connected so the start/end of one vector must match the start/end of another vector.

 1def add_vectors(*v):
 2    return tuple(sum(x) for x in zip(*v))
 3
 4
 5def subtract_vectors(v1, v2):
 6    return tuple(x[0] - x[1] for x in zip(v1, v2))
 7
 8
 9print(subtract_vectors((2, 3, 4), (0, 0, 0)))
10print(subtract_vectors((2, 3, 4), (4, 4, 4)))
11"""
12(2, 3, 4)
13(-2, -1, 0)
14"""

 1def plot_axes(ax):
 2    ax.plot((-3, 3), (0, 0), (0, 0), color="grey")
 3    ax.plot((0, 0), (-3, 3), (0, 0), color="grey")
 4    ax.plot((0, 0), (0, 0), (-3, 3), color="grey")
 5
 6
 7def plot_vector(ax, v1, v2, c):
 8    ax.plot((v1[0], v2[0]), (v1[1], v2[1]), (v1[2], v2[2]), color=c)
 9
10
11def update_axis(ax, *vectors):
12    for v in vectors:
13        plot_vector(ax, v[0], v[1], "blue")
14
15
16fig, axs = plt.subplots(
17    1, 3, figsize=(10, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
18)
19fig.suptitle(
20    f"Cross Product on a Triangle",
21    fontsize=18,
22    fontweight="bold",
23)
24
25titles = ["Vectors", "Triangle", "Cross Product"]
26for i, ax in enumerate(axs.flatten()):
27    ax.set_facecolor(plt.cm.Blues(0.1))
28    ax.set_xlim(-3, 3)
29    ax.set_ylim(-3, 3)
30    ax.set_zlim(-3, 3)
31    ax.set_xlabel("x-axis")
32    ax.set_ylabel("y-axis")
33    ax.set_zlabel("z-axis")
34    ax.set_title(titles[i])
35    plot_axes(ax)
36
37# triangle
38t = ((2, 0, 0), (0, 2, 0), (0, 0, 2))
39orig = (0, 0, 0)
40cp = add_vectors(
41    t[0], cross(subtract_vectors(t[1], t[0]), subtract_vectors(t[2], t[0]))
42)
43
44update_axis(axs[0], (orig, t[0]), (orig, t[1]), (orig, t[2]))
45update_axis(axs[1], (t[0], t[1]), (t[0], t[2]), (t[1], t[2]))
46update_axis(axs[2], (t[0], t[1]), (t[0], t[2]), (t[1], t[2]))
47plot_vector(ax, t[0], cp, "Red")
48
49plt.show()

Use of Cross Product to determine the outward side of a triangle

Use of Cross Product to determine the outward side of a triangle

Shading

shading refers to the process of altering the color of an object based on the source of light and the viewing perspective as well as the angle of the light and the angle of the object surface to the viewer. Ultimately the 3D objects are displayed on the 2D screen and based on calculations using properties like cross product and projecting the visible surfaces onto a 2D surface, the 3D object is presented for viewing.

The vertices of a shape can be plotted to display the shape or the plot_wireframe function from matplotlib can be used. Similarly, instead of calculating the surface and shading of an object, the plot_surface function is used. The following code plots a triangle using vertices as well as the plot_wireframe and plot_surface functions.

 1def plot_axes(ax):
 2    ax.plot((-2, 2), (0, 0), (0, 0), color="grey")
 3    ax.plot((0, 0), (-2, 2), (0, 0), color="grey")
 4    ax.plot((0, 0), (0, 0), (-2, 2), color="grey")
 5
 6
 7def plot_vector(ax, v1, v2, c):
 8    ax.plot((v1[0], v2[0]), (v1[1], v2[1]), (v1[2], v2[2]), color=c)
 9
10
11def plot_polygon(ax, *v):
12    for i in range(len(v)):
13        j = (i + 1) % len(v)
14        plot_vector(ax, v[i], v[j], "Blue")
15
16
17fig, axs = plt.subplots(
18    1, 3, figsize=(10, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
19)
20fig.suptitle(
21    f"Plotting a triangle in 3D",
22    fontsize=18,
23    fontweight="bold",
24)
25
26for i, ax in enumerate(axs.flatten()):
27    ax.set_facecolor(plt.cm.Blues(0.1))
28    ax.set_xlim(-1, 3)
29    ax.set_ylim(-1, 3)
30    ax.set_zlim(-1, 3)
31    ax.set_xlabel("x-axis")
32    ax.set_ylabel("y-axis")
33    ax.set_zlabel("z-axis")
34    plot_axes(ax)
35
36# triangle vertices
37triangle = [(0, 2, 0), (2, 2, 0), (0, 2, 2)]
38plot_polygon(axs[0], *triangle)
39axs[0].set_title("Vertices")
40
41x = np.array([[0, 2], [0, 0]])
42y = np.array([[2, 2], [2, 2]])
43z = np.array([[0, 0], [0, 2]])
44axs[1].plot_wireframe(x, y, z, color="Blue")
45axs[1].set_title("plot_wireframe")
46
47axs[2].plot_surface(x, y, z, color="Blue")
48axs[2].set_title("plot_surface")
49
50plt.show()

plot triangle using plot_wireframe and plot_surface functions

Plot triangle using plot_wireframe and plot_surface functions

 1def plot_vector(ax, v1, v2, c):
 2    ax.plot((v1[0], v2[0]), (v1[1], v2[1]), (v1[2], v2[2]), color=c)
 3
 4
 5def plot_polygon(ax, *v):
 6    for i in range(len(v)):
 7        j = (i + 1) % len(v)
 8        plot_vector(ax, v[i], v[j], "Blue")
 9
10
11fig, axs = plt.subplots(
12    1, 3, figsize=(10, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
13)
14fig.suptitle(
15    f"Vertices in a side",
16    fontsize=18,
17    fontweight="bold",
18)
19
20for i, ax in enumerate(axs.flatten()):
21    ax.set_facecolor(plt.cm.Blues(0.1))
22    ax.set_xlim(-1, 3)
23    ax.set_ylim(-1, 3)
24    ax.set_zlim(-1, 3)
25    ax.set_xlabel("x-axis")
26    ax.set_ylabel("y-axis")
27    ax.set_zlabel("z-axis")
28    ax.set_title(titles[i])
29
30square = [(2, 2, 2), (0, 2, 2), (0, 2, 0), (2, 2, 0)]
31plot_polygon(axs[0], *square)
32axs[0].set_title("Vertices")
33
34x = np.array([[2, 0], [2, 0]])
35y = np.array([[2, 2], [2, 2]])
36z = np.array([[2, 2], [0, 0]])
37axs[1].plot_wireframe(x, y, z, color="Blue")
38axs[1].set_title("plot_wireframe")
39
40axs[2].plot_surface(x, y, z, color="Blue")
41axs[2].set_title("plot_surface")
42
43plt.show()

plot square using plot_wireframe and plot_surface functions

Plot square using plot_wireframe and plot_surface functions

Cube

Plotting a 3D object using vertices and plotting segments and faces can get complicated without functions like plot_wireframe and plot_surface. A NumPy 2-dimensional array is used for the x,y and z coordinates. plot_surface has a number of parameters that can be used to customise the rendered object such as lightsource as used in the third plot.

 1fig, (ax1, ax2, ax3) = plt.subplots(
 2    1, 3, figsize=(10, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
 3)
 4fig.suptitle(
 5    f"Cube",
 6    fontsize=18,
 7    fontweight="bold",
 8)
 9
10for i, ax in enumerate([ax1, ax2, ax3]):
11    ax.set_facecolor(plt.cm.Blues(0.1))
12    ax.set_xlim(-1, 3)
13    ax.set_ylim(-1, 3)
14    ax.set_zlim(-1, 3)
15    ax.set_xlabel("x-axis")
16    ax.set_ylabel("y-axis")
17    ax.set_zlabel("z-axis")
18
19x = np.array(
20    [
21        [2, 0, 0, 2, 2],
22        [2, 0, 0, 2, 2],
23        [0, 2, 2, 0, 0],
24        [0, 2, 2, 0, 0],
25        [2, 0, 0, 2, 2],
26    ]
27)
28
29y = np.array(
30    [
31        [2, 2, 0, 0, 2],
32        [2, 2, 0, 0, 2],
33        [0, 0, 2, 2, 0],
34        [0, 0, 2, 2, 0],
35        [2, 2, 0, 0, 2],
36    ]
37)
38
39z = np.array(
40    [
41        [2, 2, 2, 2, 2],
42        [0, 0, 0, 0, 0],
43        [0, 0, 0, 0, 0],
44        [2, 2, 2, 2, 2],
45        [2, 2, 2, 2, 2],
46    ]
47)
48
49ax1.set_title("Wireframe")
50ax1.plot_wireframe(x, y, z)
51
52ax2.set_title("Surface")
53ax2.plot_surface(x, y, z)
54
55ax3.set_title("Light Source")
56ls = matplotlib.colors.LightSource(4, -4, 4)
57ax3.plot_surface(x, y, z, lightsource=ls)
58
59plt.show()

plot cube using plot_wireframe and plot_surface functions

Plot cube using plot_wireframe and plot_surface functions

Sphere

Like a circle or a curved line in 2D-space can be represented by a sequence of small straight lines, a curved surface in 3D-space can be represented by a collection of small triangles. The higher the number of segments the more curved the sphere will appear.

 1def create_sphere(segments):
 2    u = np.linspace(0, 2 * np.pi, segments)
 3    v = np.linspace(0, np.pi, segments)
 4    x = 20 * np.outer(np.cos(u), np.sin(v))
 5    y = 20 * np.outer(np.sin(u), np.sin(v))
 6    z = 20 * np.outer(np.ones(np.size(u)), np.cos(v))
 7    return (x, y, z)
 8
 9
10fig, (ax1, ax2, ax3) = plt.subplots(
11    1, 3, figsize=(10, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
12)
13fig.suptitle(
14    f"Sphere Wireframes",
15    fontsize=18,
16    fontweight="bold",
17)
18
19for i, ax in enumerate([ax1, ax2, ax3]):
20    ax.set_facecolor(plt.cm.Blues(0.1))
21    ax.set_xlim(-25, 25)
22    ax.set_ylim(-25, 25)
23    ax.set_zlim(-25, 25)
24    ax.set_xlabel("x-axis")
25    ax.set_ylabel("y-axis")
26    ax.set_zlabel("z-axis")
27    n = 5 * i + 10
28    ax.set_title(f"segments: {n}")
29    (x, y, z) = create_sphere(n)
30    ax.plot_wireframe(x, y, z)
31
32plt.show()

Plot sphere using plot_wireframe with increasing numbers of segments

Plot sphere wireframe with increasing numbers of segments

 1def create_sphere(segments):
 2    u = np.linspace(0, 2 * np.pi, segments)
 3    v = np.linspace(0, np.pi, segments)
 4    x = 20 * np.outer(np.cos(u), np.sin(v))
 5    y = 20 * np.outer(np.sin(u), np.sin(v))
 6    z = 20 * np.outer(np.ones(np.size(u)), np.cos(v))
 7    return (x, y, z)
 8
 9
10fig, axs = plt.subplots(
11    2, 3, figsize=(10, 8), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
12)
13fig.suptitle(
14    f"Sphere composed with increasing number of segments",
15    fontsize=18,
16    fontweight="bold",
17)
18
19for i, ax in enumerate(axs.flatten()):
20    ax.set_facecolor(plt.cm.Blues(0.1))
21    ax.set_xlim(-25, 25)
22    ax.set_ylim(-25, 25)
23    ax.set_zlim(-25, 25)
24    ax.set_xlabel("x-axis")
25    ax.set_ylabel("y-axis")
26    ax.set_zlabel("z-axis")
27    n = (10 * i) + 10
28    ax.set_title(f"segments: {n}")
29    (x, y, z) = create_sphere(n)
30    ax.plot_surface(x, y, z)
31
32plt.show()

Plot sphere using plot_surface with increasing numbers of segments

Plot sphere surface with increasing numbers of segments

Plot sphere with decreasing transparency

Plot sphere with decreasing transparency

Torus

A Torus is a geometric surface generated by revolving a circle in 3-D space about an axis that is coplanar with the circle. A real-world objects that approximate a torus of revolution is an inner tube and an example of a solid torus is a ring doughnut or bagel.

 1def create_torus(segments):
 2    u = np.linspace(0, 2 * np.pi, segments)
 3    v = np.linspace(0, 2 * np.pi, segments)
 4    u, v = np.meshgrid(u, v)
 5    a,b = 5,9
 6    x = (b + a * np.cos(u)) * np.cos(v)
 7    y = (b + a * np.cos(u)) * np.sin(v)
 8    z = a * np.sin(u)
 9    return (x, y, z)
10
11
12fig, (ax1, ax2) = plt.subplots(
13    1, 2, figsize=(10, 5), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
14)
15fig.suptitle(
16    f"Torus",
17    fontsize=18,
18    fontweight="bold",
19)
20
21(x, y, z) = create_torus(50)
22
23for i, ax in enumerate([ax1, ax2]):
24    ax.set_facecolor(plt.cm.Blues(0.1))
25    ax.set_xlim(-14, 14)
26    ax.set_ylim(-14, 14)
27    ax.set_zlim(-14, 14)
28    ax.set_xlabel("x-axis")
29    ax.set_ylabel("y-axis")
30    ax.set_zlabel("z-axis")
31
32ax1.set_title(f"wireframe")
33ax1.plot_wireframe(x, y, z)
34
35ax2.set_title(f"surface")
36ax2.plot_surface(x, y, z)
37
38plt.show()

Plot torus

Plot torus

Conclusion

The cross product of two vectors is a vector that is perpendicular to both vectors. The magnitude of the cross product vector equals the area of a parallelogram with the vectors for sides. The direction of the vector of the cross product obeys the right-hand rule.

The surface of 3D objects can be represented by a collection of triangles and the cross product of the vertices can be used to determine whether the surface is visible and level of shading to apply.

Matplotlib has functions for rendering wireframes and surfaces of 3D objects and examples of cube, sphere and torus were shown.

matplotlib a comprehensive library for creating static, animated, and interactive visualizations in Python.

Math for Programmers by Paul Orland - a great book to brush up on your math skills.

Three Dimensional Vectors and Dot Product

Eric Callanan — Sunday, 10 Jan 2021

The world around is in three dimensions, yet it is not as easy to represent on a 2D surface such as a page or screen. This article, inspired by chapter 3 of Math for Programmers book, looks at presenting 3D vectors with Matplotlib. It also shows how to calculate the length of 3D-vectors and explores the dot product of 3D vectors.

These are my notes on the book Math for Programmers by Paul Orland.

2D vectors and vector arithmetic
Two Dimensional shapes
Three Dimensional Vectors and Dot Product

3D vectors

A 2D vector can be represented as two Cartesian coordinates x and y. These represent the distance from the origin in the horizontal and vertical axes. If we imagine this 2D plane lying flat on the desk and imagine another axis rising above or below the desk, then the shapes could take on a third dimension. This axis is given the label z-axis as a measure of depth. Three Cartesian coordinates (x, y and z) are used to represent a vector in 3D-space.

 1fig = plt.figure(facecolor=plt.cm.Blues(0.2))
 2ax = fig.gca(projection="3d")
 3fig.suptitle(
 4    f"3D-vector (2,3,4)",
 5    fontsize=18,
 6    fontweight="bold",
 7)
 8
 9xs, ys, zs = zip((2, 3, 4), (0, 0, 0))
10ax.plot(xs, ys, zs, color="blue")
11ax.set_facecolor(plt.cm.Blues(0.2))
12ax.set_xlim(0, 4)
13ax.set_ylim(0, 4)
14ax.set_zlim(0, 4)
15ax.set_xlabel("x-axis")
16ax.set_ylabel("y-axis")
17ax.set_zlabel("z-axis")
18
19plt.show()

3D vector with Matplotlib

3D vector with Matplotlib

Viewing 3D vectors

It can be difficult to visualize 3D vectors and objects as these are still being presented on 2D screens and surfaces. This is the same vector plus a vector lying flat on the XY plane shown from different Viewing angles and viewing elevations. Both of these vectors have (3,4) for their (x,y) coordinates, but the blue one has a z-coordinate of 4, while the red one is flat on the XY plane (as specified with a z-coordinate of zero).

 1fig, axs = plt.subplots(
 2    1, 4, figsize=(12, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
 3)
 4fig.suptitle(
 5    f"Different 3D viewing angles",
 6    fontsize=22,
 7    fontweight="bold",
 8)
 9
10for i, ax in enumerate(axs.flatten()):
11    ax.set_facecolor(plt.cm.Blues(0.2))
12    xs, ys, zs = zip((0, 0, 0), (3, 4, 4))
13    ax.plot(xs, ys, zs, color="blue")
14    xs, ys, zs = zip((0, 0, 0), (3, 4, 0))
15    ax.plot(xs, ys, zs, color="red")
16    ax.set_xlim(0, 4)
17    ax.set_ylim(0, 4)
18    ax.set_zlim(0, 4)
19    ax.set_xlabel("x-axis")
20    ax.set_ylabel("y-axis")
21    ax.set_zlabel("z-axis")
22
23    view_angle = i * (30)
24    ax.view_init(elev=10.0, azim=view_angle)
25    ax.set_title(f"View Angle = {view_angle}", fontsize=14, pad=5)
26
27fig.tight_layout(pad=2.0)
28plt.show()
29
30publish_png_image(fig, "3d-vector-different-viewing-angles.png")

3D vector from different viewing angles

3D vector from different viewing angles

 1fig, axs = plt.subplots(
 2    1, 4, figsize=(12, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
 3)
 4fig.suptitle(
 5    f"Increasing viewing elevation",
 6    fontsize=22,
 7    fontweight="bold",
 8)
 9
10for i, ax in enumerate(axs.flatten()):
11    ax.set_facecolor(plt.cm.Blues(0.2))
12    xs, ys, zs = zip((0, 0, 0), (3, 4, 4))
13    ax.plot(xs, ys, zs, color="blue")
14    xs, ys, zs = zip((0, 0, 0), (3, 4, 0))
15    ax.plot(xs, ys, zs, color="red")
16    ax.set_xlim(0, 4)
17    ax.set_ylim(0, 4)
18    ax.set_zlim(0, 4)
19    ax.set_xlabel("x-axis")
20    ax.set_ylabel("y-axis")
21    ax.set_zlabel("z-axis")
22
23    elevation = i * 25.0
24    ax.view_init(elev=elevation)
25    ax.set_title(f"Elevation = {elevation}", fontsize=14, pad=5)
26
27fig.tight_layout(pad=2.0)
28plt.show()

3D vector from different viewing elevation

3D vector from different viewing elevation

Length of 3D vector

The Pythagorean theorem is used to calculate the length of a vector in 2D-space. This can be extended to create a formula to calculate the length of a three-dimensional vector. The central fact of 3D-space is that the three planes X, Y & Z are perpendicular to each other, so any line on one plane is at right-angles to a line on another plane.

Think of the XY plane as lying flat on a table and the Z dimension as rising vertically up. Any 3D-vector (x,y,z) will have a corresponding 2D vector (x,y) on the XY plane vertically below it. The length of (0,0) to (x,y) can be calculated using Pythagorean theorem. This line is one of The edges of a right-angled triangle with z being the second edge - allowing the calculation of the length of the 3D-vector (x,y,z).

$$ hypotenuse \ of \ xy = \sqrt{(x^2 + y^2)} $$

This hypotenuse on the XY plane is perpendicular to the Z plane so

$$ vector \ length = \sqrt{((hypotenuse \ of \ xy)^2 + z^2)} $$

$$ vector \ length = \sqrt{ \left( \sqrt{(x^2 + y^2)} \right) ^2 + z^2} $$

The inner square root and squared cancel each other out

$$ \left( \sqrt{ (x^2 + y^2)} \right) ^2 = (x^2 + y^2) $$

$$ vector \ length = \sqrt{(x^2 + y^2 + z^2)} $$

 1fig, axs = plt.subplots(
 2    1, 3, figsize=(10, 4), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
 3)
 4fig.suptitle(
 5    f"Use of Pythagorean theorem to calculate length 3D-vector",
 6    fontsize=18,
 7    fontweight="bold",
 8)
 9
10for i, ax in enumerate(axs.flatten()):
11    ax.set_facecolor(plt.cm.Blues(0.2))
12    xs, ys, zs = zip((0, 0, 0), (3, 4, 4))
13    ax.plot(xs, ys, zs, color="blue")
14    ax.set_xlim(0, 4)
15    ax.set_ylim(0, 4)
16    ax.set_zlim(0, 4)
17    ax.set_xlabel("x-axis")
18    ax.set_ylabel("y-axis")
19    ax.set_zlabel("z-axis")
20
21
22axs[1].plot((0, 3), (0, 0), (0, 0), color="teal")
23axs[1].plot((3, 3), (0, 4), (0, 0), color="teal")
24axs[1].plot((0, 3), (0, 4), (0, 0), color="teal")
25axs[1].text(1.5, 0.2, 0, "x", "x", color="teal")
26axs[1].text(2.5, 1.6, 0, "y", "y", color="teal")
27axs[1].text(0.7, 1.6, 0, r"$\sqrt{(x^2 + y^2)}$", (3, 4, 0), color="teal")
28
29
30axs[2].plot((0, 3), (0, 4), (0, 0), color="red")
31axs[2].plot((3, 3), (4, 4), (0, 4), color="red")
32axs[2].text(1.7, 0.5, 0, r"$\sqrt{(x^2 + y^2)}$", (3, 4, 0), color="red")
33axs[2].text(3.2, 4.0, 2.0, "z", "z", color="red")
34axs[2].text(1, 1, 2, r"$\sqrt{(x^2 + y^2 + z^2)}$", (3, 4, 4), color="blue")
35
36fig.tight_layout(pad=2.0)
37plt.show()

Use of Pythagorean theorem to calculate length 3D-vector

Use of Pythagorean theorem to calculate length 3D-vector

The length of a 3D-vector can be calculated in Python in a similar manner to the length of a 2D-vector. A list comprehension can be used to create a generic vector_length function that will work for multiple dimensions. This function can be used to calculate the length of vectors with dimensions greater than 3.

 1import math as m
 2
 3def vector_2d_length(v):
 4    return m.sqrt(v[0] ** 2 + v[1] ** 2)
 5
 6def vector_3d_length(v):
 7    return m.sqrt(v[0] ** 2 + v[1] ** 2 + v[2] ** 2)
 8
 9def vector_length(v):
10    return m.sqrt(sum((c ** 2) for c in v))
11
12vector_2d_length((3,4))
13"""
145.0
15"""
16
17vector_3d_length((3,4,4))
18"""
196.4031242374328485
20"""
21
22vector_length((3,4))
23"""
245.0
25"""
26
27vector_length((3,4,4))
28"""
296.4031242374328485
30"""
31
32vector_length((3,4,4,4))
33"""
347.54983443527075
35"""
36
37vector_length((3,4,5,6,7,8))
38"""
3914.106735979665885
40"""

Dot product

There are two important mechanisms of multiplying one 3D vector by another; the dot product and the cross product.

The dot product returns a scaler and works on 2D, 3D or higher number of dimensions. The dot product is the sum of the products of the corresponding entries of the two sequences of numbers. The dot product of 2 vectors is a measure of how aligned the vectors are. When vectors are pointing in the same or similar direction, the dot product is positive. When vectors are pointing in opposite direction, the dot product is negative. When two vectors are perpendicular to each other then their dot product is zero regardless of the magnitude of the vectors.

It is very straight forward to calculate the dot product in python. Again, a list comprehension is used to create a generic function that works for vectors with multiple dimensions.

 1def dot(v1, v2):
 2    return sum([c1 * c2 for c1, c2 in zip(v1, v2)])
 3
 4
 5dot((3, 4), (4, 4))
 6dot((4, 4), (-2, 2))
 7dot((-3, -4), (-4, -3))
 8dot((3, 4), (-3, -4))
 9"""
1028
110
1224
13-25
14"""
15
16
17dot((3, 4, 5), (4, 4, 4))
18dot((3, 0, 9), (-6, 4, 2))
19dot((3, -4, -5), (-4, 4, 4))
20"""
2148
220
23-48
24"""

 1def plot_vector(ax, v, c):
 2    ax.annotate(
 3        "",
 4        (v[0], v[1]),
 5        xytext=(0, 0),
 6        arrowprops=dict(ec=c, fc=c, alpha=0.6),
 7    )
 8
 9
10def update_axis(ax, v1, v2):
11    plot_vector(ax, v1, "blue")
12    plot_vector(ax, v2, "red")
13    ax.set_title(f"dot product = {dot(v1, v2)}", fontsize=14)
14
15
16fig, axs = plt.subplots(2, 3, figsize=(12, 8), facecolor=plt.cm.Blues(0.2))
17fig.suptitle(
18    f"dot product",
19    fontsize=22,
20    fontweight="bold",
21)
22
23for i, ax in enumerate(axs.flatten()):
24    ax.set_facecolor(plt.cm.Blues(0.2))
25    ax.spines["right"].set_visible(False)
26    ax.spines["top"].set_visible(False)
27    ax.spines["left"].set_position("zero")
28    ax.spines["bottom"].set_position("zero")
29    ax.set_xlim(-5, 5)
30    ax.set_ylim(-5, 5)
31    ax.set_aspect("equal")
32    ax.grid(True)
33    ax.set_xticks([x for x in range(-4, 5, 1)])
34    ax.set_yticks([x for x in range(-4, 5, 1)])
35
36update_axis(axs[0][0], (3, 4), (4, 4))
37update_axis(axs[0][1], (3, 4), (2, 2))
38update_axis(axs[0][2], (4, 4), (-2, 2))
39update_axis(axs[1][0], (-3, -4), (-4, -4))
40update_axis(axs[1][1], (3, 4), (-4, -3))
41update_axis(axs[1][2], (3, 4), (-3, -4))
42
43fig.tight_layout(pad=2.0)
44plt.show()

dot product of 2D vectors

dot product of 2D vectors

 1def plot_axes(ax):
 2    ax.plot((-4, 4), (0, 0), (0, 0), color="grey")
 3    ax.plot((0, 0), (-4, 4), (0, 0), color="grey")
 4    ax.plot((0, 0), (0, 0), (-4, 4), color="grey")
 5
 6
 7def plot_vector(ax, v, c):
 8    ax.plot((0, v[0]), (0, v[1]), (0, v[2]), color=c)
 9
10
11def update_axis(ax, v1, v2):
12    plot_axes(ax)
13    plot_vector(ax, v1, "blue")
14    plot_vector(ax, v2, "red")
15    ax.set_title(f"dot product = {dot(v1, v2)}", fontsize=14)
16
17
18fig, axs = plt.subplots(
19    2, 3, figsize=(10, 8), facecolor=plt.cm.Blues(0.2), subplot_kw={"projection": "3d"}
20)
21fig.suptitle(
22    f"dot product on 3D-vector",
23    fontsize=18,
24    fontweight="bold",
25)
26
27for i, ax in enumerate(axs.flatten()):
28    ax.set_facecolor(plt.cm.Blues(0.1))
29    ax.set_xlim(-7, 5)
30    ax.set_ylim(-5, 5)
31    ax.set_zlim(-6, 10)
32    ax.set_xlabel("x-axis")
33    ax.set_ylabel("y-axis")
34    ax.set_zlabel("z-axis")
35
36update_axis(axs[0][0], (3, 4, 5), (4, 4, 4))
37update_axis(axs[0][1], (3, 0, 9), (-6, 4, 2))
38update_axis(axs[0][2], (3, -4, -5), (-4, 4, 4))
39
40update_axis(axs[1][0], (3, 4, 5), (4, 4, 4))
41axs[1][0].view_init(azim=-80)
42update_axis(axs[1][1], (3, 0, 9), (-6, 4, 2))
43axs[1][1].view_init(azim=-80)
44update_axis(axs[1][2], (3, -4, -5), (-4, 4, 4))
45axs[1][2].view_init(azim=-80)
46
47fig.tight_layout(pad=2.0)
48plt.show()

dot product of 3D vectors

dot product of 3D vectors

Use of dot product

Two specific uses of dot product are:

Angle of a vector
Length of a vector

Angle

The dot product of two vectors is easy to calculate and can tell if the angle between two vectors is less than, greater than or equal to 90^o. More specifically, the dot product of two vectors is equal to the product of their lengths by the cosine of the angle between the vectors.

$$ v1 \cdot v2 = |v1| \cdot |v2| \cdot cos θ $$

$$ v1 \cdot v2 = |v1| \ {\times} \ |v2| \ {\times} \ cos θ $$

It is more common to want to find the angle from given coordinates, so the formula can be rearranged.

$$ cos θ = \frac {v1 \cdot v2}{|v1| \ {\times} \ |v2|} $$

$$ θ = arccos \left( \frac {v1 \cdot v2}{|v1| \ {\times} \ |v2|} \right) $$

Example of the angle between (3,4,5) and (4,4,4)

$$ θ = arccos \left( \frac {(3,4,5) \cdot (4,4,4)}{|(3,4,5)| \ {\times} \ |(4,4,4)|} \right) $$

$$ θ = arccos \left( \frac {48}{7.07 \ {\times} \ 6.928} \right) = arccos \left( \frac {48}{48.99} \right) = arccos \left( 0.979 \right) = 0.201 Radians = 11.5^{\circ} $$

This can be written in the following Python function.

 1import math as m
 2
 3
 4def angle_between_vectors(v1, v2):
 5    return m.acos(dot(v1, v2) / (vector_length(v1) * vector_length(v2))) * (180 / m.pi)
 6
 7
 8angle_between_vectors((3, 4, 5), (4, 4, 4))
 9"""
1011.536959032815467
11"""
12
13angle_between_vectors((3, 0, 9), (-6, 4, 2))
14"""
1590.0
16"""
17
18angle_between_vectors((3, -4, -5), (-4, 4, 4))
19"""
20168.46304096718453
21"""

Length

The length of a vector is the square root of the dot product of the vector by itself

$$ vector \ length = |v| = \sqrt{v \cdot v} $$

Vector length of (3,4), (3,4,4) and (3,4,4,4)

$$ vector \ length = \sqrt{v \cdot v} = \sqrt{(3,4) \cdot (3,4))} = \sqrt{25} = 5 $$

$$ vector \ length = \sqrt{v \cdot v} = \sqrt{(3,4,4) \cdot (3,4,4))} = \sqrt{41} = 6.40 $$

$$ vector \ length = \sqrt{v \cdot v} = \sqrt{(3,4,4,4) \cdot (3,4,4,4))} = \sqrt{57} = 7.55 $$

 1import math as m
 2
 3
 4def vector_len_dot(v):
 5    return m.sqrt(dot(v, v))
 6
 7
 8vector_len_dot((3,4))
 9"""
105.0
11"""
12
13vector_len_dot((3,4,5))
14"""
157.0710678118654755
16"""
17
18vector_len_dot((4,4,4))
19"""
206.928203230275509
21"""
22
23vector_len_dot((3,4,4,4))
24"""
257.54983443527075
26"""

Conclusion

This article showed how to display 3D-vectors from different angles and perspectives. Even with this, it can be difficult to visualize 3D vectors and objects as these are still being presented on 2D screens. Two mechanisms were shown of calculating the length of a 3D vector. The dot product was examined and some of its uses such as determining if vectors are perpendicular as well as calculating the exact angle between vectors or calculating the length of a vector using the dot product. Next article will look at the cross product as well as shading and plotting 3D objects.

matplotlib a comprehensive library for creating static, animated, and interactive visualizations in Python.

Math for Programmers by Paul Orland - a great book to brush up on your math skills.

Two Dimensional shapes

Eric Callanan — Sunday, 03 Jan 2021

A vector has magnitude and direction. A single point in 2D space can be considered a vector from the origin (0,0) to that point. Vectors can be described anywhere in 2D space using a point for the start and a point for the end. Multiple vectors can be connected together to create 2D shapes. This article will discuss common 2D shapes as well as rotations and translations.

These are my notes on the book Math for Programmers by Paul Orland.

2D vectors and vector arithmetic
Two Dimensional shapes

Basic shapes

Simple shapes can be drawn by combining many vectors together. A square can be drawn using four points for the corners or four vectors for the sides. For vectors to draw shapes, one vector has to start where another vectors ends. previously, vectors were described as a single point where the origin (0,0) is the starting point. Vectors do not have to start at the origin and can be specified with a start point and end point

 1def plot_axes(ax, l_left, u_right):
 2    ax.set_facecolor(plt.cm.Blues(0.1))
 3
 4    # Hide the right and top spines
 5    ax.spines["right"].set_visible(False)
 6    ax.spines["top"].set_visible(False)
 7
 8    # Set the x and y axis to go through origin (0,0)
 9    ax.spines["left"].set_position("zero")
10    ax.spines["bottom"].set_position("zero")
11
12    ax.set_xlim(l_left[0], u_right[0])
13    ax.set_ylim(l_left[1], u_right[1])
14
15    ax.grid(True)
16
17    ax.tick_params(labelsize="medium")

 1def plot_segment(ax, v1, v2):
 2    ax.plot([v1[0], v2[0]], [v1[1], v2[1]], color="green")
 3
 4
 5fig, [ax1, ax2] = plt.subplots(1, 2, figsize=(9, 6.5), facecolor=plt.cm.Blues(0.2))
 6fig.suptitle(
 7    f"Basic Shapes",
 8    fontsize=22,
 9    fontweight="bold",
10)
11
12plot_axes(ax1, (-1, -1), (6, 6))
13ax1.set_title(f"Square", fontsize=14, pad=20)
14plot_segment(ax1, (1, 2), (4, 2))
15plot_segment(ax1, (1, 2), (1, 5))
16plot_segment(ax1, (4, 2), (4, 5))
17plot_segment(ax1, (1, 5), (4, 5))
18
19plot_axes(ax2, (-1, -1), (6, 6))
20ax2.set_title(f"Triangle", fontsize=14, pad=20)
21plot_segment(ax2, (1, 1), (4, 2))
22plot_segment(ax2, (1, 1), (2, 5))
23plot_segment(ax2, (4, 2), (2, 5))
24
25fig.tight_layout(pad=3.0)
26plt.show()
27
28publish_png_image(fig, "draw-square-triangle.png")

Draw a square and triangle

Draw a square and triangle

Polygon

A Polygon is a two-dimensional figure that is described by a finite number of straight line segments connected to form a closed shape. In the code above, there is a lot of repetition to create each segment of the shape. The following defines a mechanism of plotting a polygon based on a series of points. The last point is joined to the first point to close the shape.

1def plot_polygon(ax, *vertices):
2    # join the last vertex to the first to close the shape
3    vertices = vertices + (vertices[0],)
4    ax.plot([x[0] for x in vertices], [x[1] for x in vertices], color="red")

The same two shapes of square and triangle can be plotted using this function.

 1fig, [ax1, ax2] = plt.subplots(1, 2, figsize=(9, 6.5), facecolor=plt.cm.Blues(0.2))
 2fig.suptitle(
 3    f"Basic Shapes plotted as polygons",
 4    fontsize=22,
 5    fontweight="bold",
 6)
 7
 8plot_axes(ax1, (-1, -1), (6, 6))
 9ax1.set_title(f"Square", fontsize=14, pad=20)
10square = [(1, 2), (4, 2), (4, 5), (1, 5)]
11plot_polygon(ax1, *square)
12
13plot_axes(ax2, (-1, -1), (6, 6))
14ax2.set_title(f"Triangle", fontsize=14, pad=20)
15triangle = [(1, 1), (4, 2), (2, 5)]
16plot_polygon(ax2, *triangle)
17
18fig.tight_layout(pad=3.0)
19plt.show()

Draw a square and triangle with polygons

Draw a square and triangle with polygons

Plot complex polygons

A more complicated 2D shape can be plotted just by specifying a series of points in 2D-space. The following shows the code to plot an elephant.

 1fig, ax1 = plt.subplots(1, 1, figsize=(10, 9), facecolor=plt.cm.Blues(0.2))
 2fig.suptitle(
 3    f"More complex shapes",
 4    fontsize=22,
 5    fontweight="bold",
 6)
 7
 8plot_axes(ax1, (-15, -1), (16, 23))
 9ax1.set_title(f"Elephant", fontsize=14, pad=20)
10elephant = [
11    (2, 2),
12    (6, 2),
13    (6, 9),
14    (8, 12),
15    (9, 11),
16    (10, 7),
17    (12, 5),
18    (14, 6),
19    (15, 8),
20    (13, 8),
21    (12, 7.5),
22    (11, 9),
23    (11, 16),
24    (9, 20),
25    (4, 20),
26    (-6, 21),
27    (-10, 20),
28    (-13, 17),
29    (-13, 6),
30    (-12, 12),
31    (-11.5, 9),
32    (-12, 5),
33    (-11, 2),
34    (-8, 2),
35    (-9, 5),
36    (-8, 7),
37    (-8, 4),
38    (-7, 2),
39    (-4, 2),
40    (-5, 5),
41    (-4, 8),
42    (2, 8),
43]
44plot_polygon(ax1, *elephant)
45plt.show()

Plot an elephant polygons

Plot an elephant polygons

Trigonometry and "sohcahtoa"

Trigonometry is the study of the relationships between side lengths and angles of triangles. In the previous article all vectors were described using x and y coordinates - this is the called the Cartesian coordinate system. A vector can also be described using the Polar coordinate, which consists of specifying the length (or magnitude) of the vector and the angle counter-clockwise from the horizontal.

To convert between Cartesian and Polar coordinates, we need to use the trigonometric rules from right-angled triangles. The rules can be remembered with use of the mnemonic SOHCAHTOA. The sine of an angle is equal to the length of the opposite side divided by the length of the hypotenuse (SOH); cosine equals adjacent over hypotenuse and tangent is equal to opposite over adjacent.

$$ sin θ = \frac {opposite} {hypotenuse} $$

$$ cos θ = \frac {adjacent} {hypotenuse} $$

$$ tan θ = \frac {opposite} {adjacent} $$

 1(x, y) = (3, 4)
 2fig, [ax1, ax2] = plt.subplots(1, 2, figsize=(9, 6.5), facecolor=plt.cm.Blues(0.2))
 3fig.suptitle(
 4    f"Trigonometry on a right-angled triangle",
 5    fontsize=22,
 6    fontweight="bold",
 7)
 8
 9plot_axes(ax1, (-1, -1), (4.5, 5.5))
10ax1.set_title(f"Vector at point ({x}, {y})", fontsize=14, pad=20)
11ax1.plot(x, y, color="black", marker="o", markersize=15)
12ax1.annotate(
13    "",
14    (x, y),
15    xytext=(0, 0),
16    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=25, headlength=30),
17)
18
19plot_axes(ax2, (-1, -1), (4.5, 5.5))
20ax2.set_title(f"Right-angled triangle for vector ({x}, {y})", fontsize=14, pad=20)
21ax2.plot(x, y, color="black", marker="o", markersize=15)
22ax2.annotate(
23    "", (x, y), xytext=(0, 0), arrowprops=dict(arrowstyle="-", ec="green", fc="green")
24)
25ax2.annotate(
26    "", (x, 0), xytext=(0, 0), arrowprops=dict(arrowstyle="-", ec="green", fc="green")
27)
28ax2.annotate(
29    "", (x, y), xytext=(x, 0), arrowprops=dict(arrowstyle="-", ec="green", fc="green")
30)
31ax2.annotate(
32    "",
33    (3.0, 0.5),
34    xytext=(2.5, 0),
35    arrowprops=dict(
36        arrowstyle="-",
37        color="blue",
38        connectionstyle="angle,angleA=-90,angleB=180,rad=0",
39    ),
40)
41
42
43ax2.tick_params(labelbottom=False)
44ax2.tick_params(labelleft=False)
45
46ax2.text(1.5, -0.2, "a", size=20, color="blue", ha="left", va="top")
47ax2.text(3.2, 2, "o", size=20, color="blue", ha="left", va="center")
48ax2.text(
49    1.5,
50    2.1,
51    r"h",
52    size=20,
53    color="blue",
54    ha="center",
55    va="bottom",
56    rotation=50,
57)
58ax2.annotate(
59    "",
60    (0.56, 0.8),
61    xytext=(0.85, 0),
62    arrowprops=dict(arrowstyle="-", color="blue", connectionstyle="arc3,rad=0.6"),
63)
64ax2.text(0.5, 0.1, "θ", size=20, color="blue", ha="left", va="bottom")
65
66fig.tight_layout(pad=3.0)
67plt.show()

Relationship between angles and line lengths in right-angled triangle

Relationship between angles and line lengths in a right-angled triangle

Conversion between Degrees and Radians

Angles in mathematics are often measured in Radian rather than in degrees. One radian being the angle formed with an arc the length of one radius. This means that 180 degrees is equal to π (pi) radians. Angles are generally given in degrees such as 15^o, 45^o, 90^o, etc.

$$ Angle \ in \ Radians = Angle \ in \ Degrees \times \frac {\pi} {180} $$

$$ Angle \ in \ Degrees = Angle \ in \ Radians \times \frac {180} {\pi} $$

sin, cos and tan are functions in the math module in python that take the angle in Radians. The inverse of these functions are asin, acos and atan also in the math module. These can be used to determine the angles in the right-angled triangle above with vector (3,4).

$$ sin θ = \frac {opposite} {hypotenuse} = \frac {4} {5} = 0.8 $$

sin θ = 0.8, using asin yields an angle of 0.927 radians.

$$ Angle \ in \ Degrees = Angle \ in \ Radians \times \frac {180} {\pi} = 0.927 \times \frac {180} {3.14} = 53.13^{\circ} $$

Validation of SOHCAHTOA
$$θ = 53.13^{\circ} = 0.927 \ Radians$$	$$sin \ 0.927 = 0.7998$$	$$\frac {opposite} {hypotenuse} = \frac {4} {5} = 0.8$$
$$θ = 53.13^{\circ} = 0.927 \ Radians$$	$$cos \ 0.927 = 0.600$$	$$\frac {adjacent} {hypotenuse} = \frac {3} {5} = 0.6$$
$$θ = 53.13^{\circ} = 0.927 \ Radians$$	$$tan \ 0.927 = 1.332$$	$$\frac {opposite} {adjacent} = \frac {4} {3} = 1.333$$

 1# vector of (3,4)
 2import math as m
 3angle = 4/5
 4"""
 50.8
 6"""
 7
 8m.asin(angle)
 9"""
100.9272952180016123
11"""
12
13m.asin(angle) * (180/m.pi)
14"""
1553.13010235415599
16"""
17
18m.sin(0.927), m.cos(0.927), m.tan(0.927)
19"""
200.7998228343401385 0.6002361482517589 1.3325136059694065
21"""
22
234/5, 3/5, 4/3
24"""
250.8 0.6 1.3333333333333333
26"""

Conversion between Cartesian and Polar coordinates

Cartesian coordinates specify a vector with an x-coordinate and a y-coordinate stating the horizontal and vertical distance from the origin. Polar coordinates specify the length (magnitude) of the vector and the angle from the horizontal axis.

There is a problem with relying on results of the inverse functions asin, acos and atan in that different coordinates may yield the same angle. Consider the vectors (3,4) and (-3,4) both have opposite length of 4 and hypotenuse length of 5. Multiple angles have the same sine, so the inverse sine gives one of these angles. It is possible to use inverse of all three functions to determine the exact angle, but the math module in python contains the function atan2 to get the correct angle based on vector coordinates.

 1help(m.atan2)
 2
 3"""
 4Help on built-in function atan2 in module math:
 5
 6atan2(y, x, /)
 7    Return the arc tangent (measured in radians) of y/x.
 8
 9    Unlike atan(y/x), the signs of both x and y are considered.
10"""

The following function makes use of math.atan2 to convert from Cartesian to Polar coordinates.

 1import math as m
 2
 3
 4def to_polar(v):
 5    angle = m.atan2(v[1], v[0])
 6    length = m.sqrt(v[0] ** 2 + v[1] ** 2)
 7    return (length, angle)
 8
 9
10print(to_polar((3, 4)))
11print(to_polar((-3, 4)))
12"""
13(5.0, 0.9272952180016122)
14(5.0, 2.214297435588181)
15"""

 1def to_cartesian(polar_v):
 2    return (polar_v[0] * m.cos(polar_v[1]), polar_v[0] * m.sin(polar_v[1]))
 3
 4
 5print(to_cartesian((5, 0.927)))
 6print(to_cartesian((5, 2.215)))
 7"""
 8(3.0011807412587945, 3.9991141717006924)
 9(-3.0028095170209874, 3.9978913197444705)
10"""

 1(x, y) = (3, 4)
 2fig, [ax1, ax2] = plt.subplots(1, 2, figsize=(9, 6), facecolor=plt.cm.Blues(0.2))
 3fig.suptitle(
 4    f"Cartesian and Polar coordinates",
 5    fontsize=22,
 6    fontweight="bold",
 7)
 8
 9plot_axes(ax1, (-1, -1), (4.5, 5.5))
10ax1.set_title(f"Cartesian coordinates", fontsize=14, pad=20)
11ax1.annotate(
12    "",
13    (x, y),
14    xytext=(0, 0),
15    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=25, headlength=30),
16)
17ax1.text(3.1, 4.3, "(3, 4)", size=20, color="blue", ha="center", va="center")
18
19
20plot_axes(ax2, (-1, -1), (4.5, 5.5))
21ax2.set_title(f"Polar coordinates", fontsize=14, pad=20)
22ax2.annotate(
23    "",
24    (x, y),
25    xytext=(0, 0),
26    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=25, headlength=30),
27)
28ax2.text(
29    1.4,
30    2.1,
31    r"5",
32    size=20,
33    color="blue",
34    ha="center",
35    va="bottom",
36    rotation=50,
37)
38ax2.annotate(
39    "",
40    (1.0, 1.3),
41    xytext=(1.6, 0),
42    arrowprops=dict(arrowstyle="<->", color="blue", connectionstyle="arc3,rad=0.4"),
43)
44ax2.text(0.4, 0.1, "0.927", size=20, color="blue", ha="left", va="bottom")
45
46fig.tight_layout(pad=1.0)
47plt.show()

Same vector described with Cartesian and Polar coordinates

Same vector described with Cartesian and Polar coordinates

Regular Polygons

A Regular polygon is a polygon where all angles are equal in measure and all sides have the same length. Polar coordinates can be used to quickly create a series of regular polygons, but it ie easier in Matplotlib to plot with Cartesian coordinates. These are regular polygons that fit inside a circle of radius 1.5.

 1def regular_polygon(n):
 2    return [to_cartesian((1.5, 2 * m.pi * x / n)) for x in range(0, n)]
 3
 4
 5fig, axs = plt.subplots(2, 4, figsize=(9, 6), facecolor=plt.cm.Blues(0.2))
 6fig.suptitle(
 7    f"Regular polygons",
 8    fontsize=22,
 9    fontweight="bold",
10)
11
12for i, ax in enumerate(axs.flatten()):
13    plot_axes(ax, (-2, -2), (2, 2))
14    ax.tick_params(labelbottom=False)
15    ax.tick_params(labelleft=False)
16    n = i + 3
17    ax.set_title(f"{n} sides", fontsize=14, pad=5)
18    p = regular_polygon(n)
19    plot_polygon(ax, *p)
20
21fig.tight_layout(pad=2.0)
22plt.show()

Regular polygons created with Polar coordinates and plotted with Cartesian coordinates

Regular polygons created with Polar coordinates and plotted with Cartesian coordinates

Rotation, Scaling and translation

Now that we have basic shapes, regular polygons and complex shapes, it is possible to plot the shapes, rotate the shapes, move or translate the shapes and/or change the size of (scale) the shapes. Translation moves every point of a shape by the same distance in a given direction. This can be achieved by adding the same (x,y) values to all coordinates of the shape. Rotate moves the shape around the origin by a specified angle, this is more easily done using polar coordinates. Scale is used to multiply each vector in a shape by a specified factor, a factor larger than 1 will increase the size of a shape and a factor less than 1 will decrease the size of the shape. The following functions are used to scale, transform and rotate and the plot_polygon function is updated to take a color as a parameter.

 1def plot_polygon(ax, color, *vertices):
 2    # join the last vertex to the first to close the shape
 3    vertices = vertices + (vertices[0],)
 4    ax.plot([x[0] for x in vertices], [x[1] for x in vertices], color=color)
 5
 6
 7def scale(n, v):
 8    return (n * v[0], n * v[1])
 9
10
11def translate(tran_v, vectors):
12    return [(tran_v[0] + v[0], tran_v[1] + v[1]) for v in vectors]
13
14
15def rotate(angle, vectors):
16    polar_vectors = [to_polar(v) for v in vectors]
17    return [to_cartesian((l, a + angle)) for l, a in polar_vectors]

 1elephant = [
 2    (2, 2),
 3    (6, 2),
 4    (6, 9),
 5    (8, 12),
 6    (9, 11),
 7    (10, 7),
 8    (12, 5),
 9    (14, 6),
10    (15, 8),
11    (13, 8),
12    (12, 7.5),
13    (11, 9),
14    (11, 16),
15    (9, 20),
16    (4, 20),
17    (-6, 21),
18    (-10, 20),
19    (-13, 17),
20    (-13, 6),
21    (-12, 12),
22    (-11.5, 9),
23    (-12, 5),
24    (-11, 2),
25    (-8, 2),
26    (-9, 5),
27    (-8, 7),
28    (-8, 4),
29    (-7, 2),
30    (-4, 2),
31    (-5, 5),
32    (-4, 8),
33    (2, 8),
34]
35
36fig, axs = plt.subplots(2, 2, figsize=(12, 8), facecolor=plt.cm.Blues(0.2))
37fig.suptitle(
38    f"Translate, Scale and Rotate shapes",
39    fontsize=22,
40    fontweight="bold",
41)
42
43titles = ["Elephant", "Scale", "Translate", "Rotate"]
44for i, ax in enumerate(axs.flatten()):
45    plot_axes(ax, (-20, -1), (30, 30))
46    ax.spines["bottom"].set_visible(False)
47    ax.spines["left"].set_visible(False)
48    n = i + 3
49    ax.set_title(f"{titles[i]}", fontsize=14, pad=5)
50    plot_polygon(ax, "red", *elephant)
51
52small_elephant = [scale(0.5, x) for x in elephant]
53plot_polygon(axs[0][1], "blue", *small_elephant)
54
55tran_elephant = translate((15, 6), elephant)
56plot_polygon(axs[1][0], "blue", *tran_elephant)
57
58rot_elephant = rotate(0.2, elephant)
59plot_polygon(axs[1][1], "blue", *rot_elephant)
60
61fig.tight_layout(pad=2.0)
62plt.show()

Scale, translate and rotate elephant shape

Scale, translate and rotate elephant shape

A variation of translation is reflection where the vectors of a shape are translated proportionally through a vertical line. Reflection through the maximum x coordinate is shown below to give the elephant a friend.

 1def vertical_reflection(vectors):
 2    # find max x value
 3    mir_x = max([x[0] for x in elephant])
 4    return [((-1 * (v[0] - mir_x)) + mir_x, v[1]) for v in vectors]
 5
 6
 7fig, ax = plt.subplots(1, 1, figsize=(10, 5), facecolor=plt.cm.Blues(0.2))
 8fig.suptitle(
 9    f"Reflection of a 2D shape",
10    fontsize=22,
11    fontweight="bold",
12)
13
14plot_axes(ax, (-20, -1), (50, 25))
15ax.spines["bottom"].set_visible(False)
16ax.spines["left"].set_visible(False)
17plot_polygon(ax, "red", *elephant)
18mirror_elephant = vertical_reflection(elephant)
19plot_polygon(ax, "blue", *mirror_elephant)
20
21fig.tight_layout(pad=2.0)
22plt.show()

Reflection of elephant shape

Reflection of elephant shape

Conclusion

This article has completed the sections on 2D-space. Plotting basic and complex shapes using Matplotlib was detailed. A walk-through of trigonometric functions on a right-angled triangle and their use in converting between Polar and Cartesian coordinates. Once the initial shapes are plotted multiple versions of the shape can be generated using translation, rotation and scaling of vectors. Next article will start on 3 dimensional space and building on functions used in 2D-space.

matplotlib a comprehensive library for creating static, animated, and interactive visualizations in Python.

Math for Programmers by Paul Orland - a great book to brush up on your math skills.

2D vectors and vector arithmetic

Eric Callanan — Sunday, 27 Dec 2020

This is the first article on my notes from reading Math for Programmers. It looks at representing 2D vectors graphically with Matplotlib and visualising vector arithmetic.

I recently purchased the book Math for Programmers by Paul Orland. I'm going to write a series or articles to help me work through some of the exercises and to keep notes as I go through the book. This will not be a rewrite of the book and may focus on other areas inspired by the book.

A vector is a quantity that has magnitude and direction and that is commonly represented by a directed line segment.

Two-dimensional space (2D space) is flat like a sheet of paper with only two dimensions height and width.

Points in two-dimensional space

2 dimensional space is flat like a sheet of paper with the width being measured along the horizontal axis (x-axis) and height being measured along the vertical axis (y-axis). Conceptually the two axes extend to positive and negative infinity in both directions, but generally a section is chosen to contain the points of interest. The origin, where x = 0 and y = 0 is the reference point for all other points in the 2D plane. It is possible to describe any point in the 2D plane with two pieces of information - the x and y coordinates. The following code renders a chart showing the point (2, 3) in a 2D plane. This point is 2 units horizontally from the origin and 3 units vertically from the origin.

 1(x, y) = (2, 3)
 2fig, ax = plt.subplots(figsize=(10, 10), facecolor=plt.cm.Blues(0.2))
 3fig.suptitle(f"Point ({x}, {y}) in 2D space", fontsize="xx-large", fontweight="bold")
 4ax.set_facecolor(plt.cm.Blues(0.2))
 5ax.plot(x, y, color=plt.cm.Set1(0), marker="X", markersize=15)
 6
 7# Hide the right and top spines
 8ax.spines["right"].set_visible(False)
 9ax.spines["top"].set_visible(False)
10
11# Set the x and y axis to go through origin (0,0)
12ax.spines["left"].set_position("zero")
13ax.spines["bottom"].set_position("zero")
14
15plt.xlim((-4, 4))
16plt.ylim((-4, 4))
17plt.grid(True)
18
19ax.tick_params(labelsize="xx-large")
20
21ax.annotate("", (0, 3.2), xytext=(2, 3.2), arrowprops=dict(arrowstyle="<->", ec="blue"))
22ax.text(1, 3.3, "2", size=20, color="blue", ha="center", va="bottom")
23
24ax.annotate("", (2.2, 0), xytext=(2.2, 3), arrowprops=dict(arrowstyle="<->", ec="blue"))
25ax.text(2.4, 1.5, "3", size=20, color="blue", ha="center", va="center")
26
27plt.show()

2d chart showing point (2,3)

The point (2,3) in two-dimensional plane

Three ways to represent a vector in 2D Space

A vector is a quantity that has magnitude and direction in multi-dimensional space, a 2D-vector is easier to understand and represent by a directed line segment in a 2D plane. A 2D-vector is a point in the 2D plane represented by a line segment from the origin to the point. In the example above, the point (2,3) can be drawn as a directed line from the origin (0, 0) to (2, 3). The third way of representing a 2D-vector is by the length of the directed line and the angle that line is set from the horizontal.

The following code show the three mechanisms of representing the same 2D-vector in two-dimensional space. The point (-3, 4) because the length of the vector is 5.

 1def plot_axes(ax, p):
 2    (x, y) = (p[0], p[1])
 3    ax.set_facecolor(plt.cm.Blues(0.1))
 4    ax.plot(x, y, color="black", marker="o", markersize=15)
 5
 6    # Hide the right and top spines
 7    ax.spines["right"].set_visible(False)
 8    ax.spines["top"].set_visible(False)
 9
10    # Set the x and y axis to go through origin (0,0)
11    ax.spines["left"].set_position("zero")
12    ax.spines["bottom"].set_position("zero")
13
14    ax.set_xlim((min(0, x) - 1.5), (max(0, x) + 1.5))
15    ax.set_ylim((min(0, y) - 1.5), (max(0, y) + 1.5))
16    ax.grid(True)
17    ax.tick_params(labelsize="xx-large")

 1(x, y) = (-3, 4)
 2fig, [ax1, ax2, ax3] = plt.subplots(1, 3, figsize=(20, 8), facecolor=plt.cm.Blues(0.2))
 3fig.suptitle(
 4    f"Three ways to represent a vector in 2D space", fontsize=30, fontweight="bold"
 5)
 6plot_axes(ax1, (x, y))
 7ax1.set_title("Point at (x,y)", fontsize=22, pad=20)
 8ax1.annotate("", (x, 0), xytext=(x, y), arrowprops=dict(arrowstyle="<->", ec="blue"))
 9ax1.text(-3.2, 2, "4", size=20, color="blue", ha="center", va="center")
10ax1.annotate("", (0, y), xytext=(x, y), arrowprops=dict(arrowstyle="<->", ec="blue"))
11ax1.text(-1.5, 4.2, "-3", size=20, color="blue", ha="center", va="center")
12
13plot_axes(ax2, (x, y))
14ax2.set_title("Arrow from origin to point (x,y)", fontsize=22, pad=20)
15ax2.plot(0, 0, color="black", marker="o", markersize=10)
16ax2.annotate(
17    "",
18    (x, y),
19    xytext=(0, 0),
20    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=20, headlength=50),
21)
22ax2.tick_params(labelbottom=False)
23ax2.tick_params(labelleft=False)
24ax2.text(-3.5, 4.3, "(-3, 4)", size=20, color="blue", ha="left", va="center")
25ax2.text(0.0, -0.3, "(0, 0)", size=20, color="blue", ha="left", va="center")
26
27plot_axes(ax3, (x, y))
28ax3.set_title("Arrow with distance at angle θ", fontsize=22, pad=20)
29ax3.annotate(
30    "",
31    (x, y),
32    xytext=(0, 0),
33    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=20, headlength=50),
34)
35ax3.text(-1.5, 2.1, "5", size=20, color="blue", ha="left", va="center", rotation=-50)
36ax3.spines["left"].set_visible(False)
37ax3.tick_params(labelbottom=False)
38ax3.tick_params(labelleft=False)
39ax3.annotate(
40    "",
41    (-0.4, 0.7),
42    xytext=(0.6, 0),
43    arrowprops=dict(color="blue", connectionstyle="arc3,rad=0.6"),
44)
45ax3.text(0, 0.1, "θ", size=26, color="blue", ha="left", va="bottom")
46
47fig.tight_layout(pad=2.0)
48plt.show()
49
50publish_png_image(fig, "three-ways-2d-vector.png")

Three ways to represent a 2D-vector

Three ways to represent a 2D-vector

Right angled triangle

Pythagorean theorem

The two dimensions in 2D space are horizontal and vertical, which are perpendicular to each other. This can be used to calculate the length of a vector with the help of the Pythagorean theorem. The Pythagorean theorem states that, in a right-angled triangle, the square on the hypotenuse is equal to the sum of the squares of the other two sides.

In a right-angled triangle with sides of a and b and hypotenuse c then the length of c is the square root of the sum of a-squared and b-squared.

$$ c = \sqrt{a^2 + b^2} $$

In the example the vector (3,4) below: $$ vector \ length = \sqrt{3^2 + 4^2} = \sqrt{9 + 16} = \sqrt{25} = 5 $$

 1(x, y) = (3, 4)
 2fig, [ax1, ax2] = plt.subplots(1, 2, figsize=(12, 8), facecolor=plt.cm.Blues(0.2))
 3fig.suptitle(
 4    f"Use Pythagorean theorem to calculate length of vector",
 5    fontsize=22,
 6    fontweight="bold",
 7)
 8
 9plot_axes(ax1, (x, y))
10ax1.set_title("Vector at point (3, 4)", fontsize=18, pad=20)
11ax1.annotate(
12    "",
13    (x, y),
14    xytext=(0, 0),
15    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=20, headlength=50),
16)
17
18plot_axes(ax2, (x, y))
19ax2.set_title("Right-angled triangle for vector (3,3)", fontsize=18, pad=20)
20ax2.annotate(
21    "", (x, y), xytext=(0, 0), arrowprops=dict(arrowstyle="-", ec="green", fc="green")
22)
23ax2.annotate(
24    "", (x, 0), xytext=(0, 0), arrowprops=dict(arrowstyle="-", ec="green", fc="green")
25)
26ax2.annotate(
27    "", (x, y), xytext=(x, 0), arrowprops=dict(arrowstyle="-", ec="green", fc="green")
28)
29ax2.tick_params(labelbottom=False)
30ax2.tick_params(labelleft=False)
31
32ax2.text(1.5, -0.2, "3", size=20, color="blue", ha="left", va="top")
33ax2.text(3.2, 2, "4", size=20, color="blue", ha="left", va="center")
34ax2.text(
35    1.3,
36    1.5,
37    r"$\sqrt{(3^2 + 4^2)}$",
38    size=20,
39    color="blue",
40    ha="center",
41    va="bottom",
42    rotation=50,
43)
44
45fig.tight_layout(pad=3.0)
46plt.show()

use pythagorean theorem to calculate vector length

Use of pythagorean theorem to calculate vector length

The length of a vector can be calculated in python with use of the Math functions module.

 1import math as m
 2
 3
 4def vector_length(v):
 5    return m.sqrt(v[0] ** 2 + v[1] ** 2)
 6
 7
 8for i in range(1, 6):
 9    v = (i, 4)
10    print(f"length of {v} is {vector_length(v):.1F}")
11
12"""
13length of (1, 4) is 4.1
14length of (2, 4) is 4.5
15length of (3, 4) is 5.0
16length of (4, 4) is 5.7
17length of (5, 4) is 6.4
18"""

Adding Vectors

Vectors can be added together by adding their individual constituent parts. In a way, this has already been done when considering a single vector like (3,4). This is composed of an x value of 3 and a y value of 4, which are vectors (3,0) and (0,4) and can be added to yield (3,4).

$$ (x_{1}, y_{1}) + (x_{2}, y_{2}) = (x_{1} + x_{2}, \ y_{1} + y_{2}) $$

The example shows the result of adding vector (3,4) to vector (-2, 1)

$$ (3, 4) + (-2, 1) = (3 + (-2), \ 4 + 1) = (1, 5) $$

 1(x1, y1) = (3, 4)
 2(x2, y2) = (-2, 1)
 3fig, axs = plt.subplots(1, 2, figsize=(12, 6), facecolor=plt.cm.Blues(0.2))
 4fig.suptitle(
 5    f"Adding two vectors",
 6    fontsize=22,
 7    fontweight="bold",
 8)
 9
10for a in axs:
11    a.set_facecolor(plt.cm.Blues(0.1))
12    a.plot(x1, y1, color="black", marker="o", markersize=15)
13    a.plot(x2, y2, color="black", marker="o", markersize=15)
14    a.spines["right"].set_visible(False)
15    a.spines["top"].set_visible(False)
16    a.spines["left"].set_position("zero")
17    a.spines["bottom"].set_position("zero")
18    a.set_xlim(-3.5, 4.5)
19    a.set_ylim(-0.5, 5.5)
20    a.grid(True)
21    a.tick_params(labelsize="large")
22
23axs[0].set_title(f"Vectors at point ({x1}, {y1}) and ({x2}, {y2})", fontsize=18, pad=20)
24axs[0].annotate(
25    "",
26    (x1, y1),
27    xytext=(0, 0),
28    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=20, headlength=50),
29)
30axs[0].annotate(
31    "",
32    (x2, y2),
33    xytext=(0, 0),
34    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=20, headlength=50),
35)
36
37
38axs[1].set_title(f"Sum of vectors = (1, 5)", fontsize=18, pad=20)
39axs[1].plot(x1 + x2, y1 + y2, color="black", marker="*", markersize=15)
40axs[1].annotate(
41    "",
42    (x1 + x2, y1 + y2),
43    xytext=(0, 0),
44    arrowprops=dict(ec=plt.cm.Set1(2), fc=plt.cm.Set1(2), headwidth=20, headlength=50),
45)
46axs[1].annotate(
47    "",
48    (x1, y1),
49    xytext=(0, 0),
50    arrowprops=dict(ls="--", arrowstyle="->", ec=plt.cm.Set1(0), fc=plt.cm.Set1(0)),
51)
52axs[1].annotate(
53    "",
54    (x2, y2),
55    xytext=(0, 0),
56    arrowprops=dict(ls="--", arrowstyle="->", ec=plt.cm.Set1(0), fc=plt.cm.Set1(0)),
57)
58axs[1].annotate(
59    "",
60    (x1 + x2, y1 + y2),
61    xytext=(x2, y2),
62    arrowprops=dict(ls="--", arrowstyle="->", ec=plt.cm.Set1(1), fc=plt.cm.Set1(1)),
63)
64axs[1].annotate(
65    "",
66    (x1 + x2, y1 + y2),
67    xytext=(x1, y1),
68    arrowprops=dict(ls="--", arrowstyle="->", ec=plt.cm.Set1(1), fc=plt.cm.Set1(1)),
69)
70
71
72fig.tight_layout(pad=3.0)
73plt.show()

Adding two vectors

Adding two vectors is the sum of the individual component parts

Addition can be extended to sum up any number of vectors by summing up their constituent parts. This can easily be performed in python by taking in a list of vectors and returning the resultant vector of the sum of the vectors.

 1def add_vectors(*v):
 2    return (sum([x[0] for x in v]), sum([x[1] for x in v]))
 3
 4
 5add_vectors((-2, 1), (3,4))
 6"""
 7(1, 5)
 8"""
 9
10add_vectors((1, 2), (0,6), (3,4))
11"""
12(4, 12)
13"""
14
15add_vectors((1, 2), (-5,-3), (3,4))
16"""
17(-1, 3)
18"""

Multiplying vectors by numbers

The addition of two identical vectors is equivalent to multiplying the vector by two. This can be extended to multiplying a vector by any number. Like addition, the resultant vector is got by multiplying the individual components by the number.

$$ (x, y) {\times} n = (x {\times} n, \ y {\times} n) $$

 1(x, y) = (3, 4)
 2fig, axs = plt.subplots(1, 2, figsize=(10, 7), facecolor=plt.cm.Blues(0.2))
 3fig.suptitle(
 4    f"Multiplying vector by a number",
 5    fontsize=22,
 6    fontweight="bold",
 7)
 8
 9for a in axs:
10    a.set_facecolor(plt.cm.Blues(0.1))
11    a.plot(x, y, color="black", marker="o", markersize=15)
12    a.spines["right"].set_visible(False)
13    a.spines["top"].set_visible(False)
14    a.spines["left"].set_position("zero")
15    a.spines["bottom"].set_position("zero")
16    a.set_xlim(-1.5, 13)
17    a.set_ylim(-2, 18)
18    a.set_aspect("equal")
19    a.grid(True)
20    a.set_xticks([x for x in range(0, 13, 2)])
21    a.set_yticks([x for x in range(0, 18, 2)])
22    a.tick_params(labelsize="medium")
23
24axs[0].set_title(f"Vector at point ({x}, {y})", fontsize=18, pad=20)
25axs[0].annotate(
26    "",
27    (x, y),
28    xytext=(0, 0),
29    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=25, headlength=30),
30)
31
32axs[1].set_title(f"Multiplication of vector by 2,3,4", fontsize=18, pad=20)
33for i in range(1, 5):
34    axs[1].plot(x * i, y * i, color="black", marker="*", markersize=15)
35    axs[1].annotate(
36        "",
37        (x * i, y * i),
38        xytext=(0, 0),
39        arrowprops=dict(
40            ec=plt.cm.Set1(0), alpha=0.2, fc=plt.cm.Set1(0), headwidth=25, headlength=30
41        ),
42    )
43
44fig.tight_layout(pad=3.0)
45plt.show()

multiplying vector by a number

Multiplying vector (3,4) by number 2, 3 and 4

A function can be created in python to multiply a vector by a number.

 1def multiply_vector(v, n):
 2    return (v[0] * n, v[1] * n)
 3
 4
 5for i in range(1, 6):
 6    print(f"vector (3,4) * {i} = {multiply_vector((3,4), i)}")
 7
 8"""
 9vector (3,4) * 1 = (3, 4)
10vector (3,4) * 2 = (6, 8)
11vector (3,4) * 3 = (9, 12)
12vector (3,4) * 4 = (12, 16)
13vector (3,4) * 5 = (15, 20)
14"""

Back to Pythagorean principle, it can be seen that scaling the vector (3,4) maintains the principle that the sum on the hypotenuse equals the sum of the squares on the other two sides. the famous triangle of 3,4,5 scales to other whole number combinations such as 6,8,10 or 15, 20, 25.

Table: vector (3,4) multiplied by factors showing the Pythagorean calculations

Vector	factor	x-squared	y-Squared	sum	square root
(3, 4)	1	9	16	25	5.0
(6, 8)	2	36	64	100	10.0
(9, 12)	3	81	144	225	15.0
(12, 16)	4	144	256	400	20.0
(15, 20)	5	225	400	625	25.0

Distance and Displacement

In geometry, Displacement is a vector whose length is the shortest distance from the initial to the final position of a point P undergoing motion. Displacement quantifies both the distance and direction along a straight line, whereas distance just measures the distance between two points without any direction.

The difference between two vectors is a displacement vector, although this includes the distance.

The displacement from (4,2) to (1,4) is (-3, 2)

$$ distance = \sqrt{-3^2 + 2^2} = \sqrt{9 + 4} = \sqrt{13} = 3.6 $$

 1(x1, y1) = (4, 2)
 2(x2, y2) = (1, 4)
 3fig, axs = plt.subplots(1, 2, figsize=(12, 6), facecolor=plt.cm.Blues(0.2))
 4fig.suptitle(
 5    f"Displacement from ({x1}, {y1}) to ({x2}, {y2}) is ({x2-x1}, {y2-y1})",
 6    fontsize=22,
 7    fontweight="bold",
 8)
 9
10for a in axs:
11    a.set_facecolor(plt.cm.Blues(0.1))
12    a.plot(x1, y1, color="black", marker="o", markersize=15)
13    a.plot(x2, y2, color="black", marker="o", markersize=15)
14    a.text(1, 4.3, f"({x2}, {y2})", size=16, color="blue", ha="center", va="bottom")
15    a.text(4, 2.4, f"({x1}, {y1})", size=16, color="blue", ha="center", va="bottom")
16    a.spines["right"].set_visible(False)
17    a.spines["top"].set_visible(False)
18    a.spines["left"].set_position("zero")
19    a.spines["bottom"].set_position("zero")
20    a.set_xlim(-3.5, 4.5)
21    a.set_ylim(-0.5, 5.5)
22    a.grid(True)
23    a.tick_params(labelsize="large")
24
25axs[0].set_title(f"Vectors ({x1}, {y1}) and ({x2}, {y2})", fontsize=18, pad=20)
26axs[0].annotate(
27    "",
28    (x1, y1),
29    xytext=(0, 0),
30    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=25, headlength=30),
31)
32axs[0].annotate(
33    "",
34    (x2, y2),
35    xytext=(0, 0),
36    arrowprops=dict(ec=plt.cm.Set1(0), fc=plt.cm.Set1(0), headwidth=25, headlength=30),
37)
38
39
40axs[1].set_title(f"Sum of vectors = (1, 5)", fontsize=18, pad=20)
41axs[1].plot(x2 - x1, y2 - y1, color="black", marker="*", markersize=15)
42axs[1].annotate(
43    "",
44    (x2 - x1, y2 - y1),
45    xytext=(0, 0),
46    arrowprops=dict(ec=plt.cm.Set1(1), fc=plt.cm.Set1(1), headwidth=25, headlength=30),
47)
48axs[1].annotate(
49    "",
50    (x1, y1),
51    xytext=(0, 0),
52    arrowprops=dict(ls="--", arrowstyle="->", ec=plt.cm.Set1(0), fc=plt.cm.Set1(0)),
53)
54axs[1].annotate(
55    "",
56    (x2, y2),
57    xytext=(0, 0),
58    arrowprops=dict(ls="--", arrowstyle="->", ec=plt.cm.Set1(0), fc=plt.cm.Set1(0)),
59)
60axs[1].annotate(
61    "",
62    (x2, y2),
63    xytext=(x1, y1),
64    arrowprops=dict(ec=plt.cm.Set1(1), fc=plt.cm.Set1(1), headwidth=25, headlength=30),
65)
66
67
68axs[1].text(
69    -1.1,
70    0.7,
71    f"({x2-x1}, {y2-y1})",
72    size=16,
73    color=plt.cm.Set1(1),
74    ha="center",
75    va="bottom",
76    rotation=-32,
77)
78axs[1].text(
79    2.9,
80    2.7,
81    f"({x2-x1}, {y2-y1})",
82    size=16,
83    color=plt.cm.Set1(1),
84    ha="center",
85    va="bottom",
86    rotation=-32,
87)
88
89fig.tight_layout(pad=3.0)
90plt.show()

subtracting vectors to get displacement

Subtracting vectors to get displacement

Conclusion

This took me longer than I thought to write this article, but it has helped me learn more on Matplotlib and doing math with 2D vectors. The next article is still on 2 dimensional space with notes on segments, shapes, rotations and transformations.

matplotlib a comprehensive library for creating static, animated, and interactive visualizations in Python.

Math for Programmers by Paul Orland - a great book to brush up on your math skills.

mathplotlib on Software Development Notes

Three Dimensional Shapes and Shading

Cross product

Length of Cross Product

Triangle composed of 3 vectors

Shading

Cube

Sphere

Torus

Conclusion

Three Dimensional Vectors and Dot Product

3D vectors

Viewing 3D vectors

Length of 3D vector

Dot product

Use of dot product

Angle

Length

Conclusion

Two Dimensional shapes

Basic shapes

Polygon

Plot complex polygons

Trigonometry and "sohcahtoa"

Conversion between Degrees and Radians

Validation of SOHCAHTOA

Conversion between Cartesian and Polar coordinates

Regular Polygons

Rotation, Scaling and translation

Conclusion

2D vectors and vector arithmetic

Points in two-dimensional space

Three ways to represent a vector in 2D Space

Right angled triangle

Pythagorean theorem

Adding Vectors

Multiplying vectors by numbers

Distance and Displacement

Conclusion