¿Cómo trazar un ángulo en Python usando Matplotlib?

En este artículo, aprenderemos a trazar un ángulo en Python. Como sabemos que para dibujar un ángulo, debe haber dos líneas que se intersecan para que el ángulo se pueda formar entre esas dos líneas en un punto de intersección. En esto, trazamos un ángulo en dos líneas rectas que se cruzan. Entonces, primero analicemos algunos conceptos:

• NumPy es un paquete de procesamiento de arrays de propósito general. Proporciona un objeto de array multidimensional de alto rendimiento y herramientas para trabajar con estas arrays.
• Matplotlib es una increíble biblioteca de visualización en Python para gráficos 2D de arrays. Matplotlib es una biblioteca de visualización de datos multiplataforma basada en arrays NumPy y diseñada para funcionar con la pila SciPy más amplia. Fue presentado por John Hunter en el año 2002.

En este matplotlib se usa para trazar ángulos gráficamente y encaja mejor con Numpy mientras que NumPy es Python numérico que se usa para realizar Advance Mathematics .

Pasos necesarios

1. Trace dos líneas de intersección.
2. Encuentra el punto de Intersección marcado con un color.
3. Trace un círculo de tal manera que el punto de intersección de dos líneas sea el mismo que el centro del círculo.
4. Márcalo como un punto donde el círculo se intersecará con líneas rectas y marca esos dos puntos donde encontramos el ángulo entre ellos.
5. Calcular el ángulo y trazar el ángulo.

Implementación paso a paso

1. Trace dos líneas de intersección

• En esto, las dos primeras líneas de código muestran que se importan matplotlib y NumPy Framework of Python, desde donde usaremos funciones integradas en código adicional.
• Después de eso, se toman la pendiente y la intersección para trazar dos líneas rectas. Después de ese espacio de línea ( l ) devuelve espacios numéricos uniformemente con respecto al intervalo.
• Después de eso, plt.figure() se usa para crear el área donde trazamos el ángulo y su dimensión se proporciona en el código.
• Después de eso, para trazar las líneas rectas, tenemos que definir el eje. Aquí: eje X: 0-6 y eje Y: 0-6
• El título se le da al cuadro de la figura usando plt.title().

Después de eso, se trazan dos líneas como se muestra en el siguiente resultado: 

# import packages
import matplotlib.pyplot as plt
import numpy as np
 
# slope  and intercepts
a1, b1 = (1/4), 1.0
a2, b2 = (3/4), 0.0
 
# The numpy.linspace() function returns
# number spaces evenly w.r.t interval
l = np.linspace(-6, 6, 100)
 
# use to create new figure
plt.figure(figsize=(8, 8))
 
# plotting
plt.xlim(0, 6)
plt.ylim(0, 6)
plt.title('Plot an angle using Python')
plt.plot(l, l*a1+b1)
plt.plot(l, l*a2+b2)
plt.show()

Producción :

2. Encuentra el punto de Intersección y marca con un color

Aquí x0, y0 denotan el punto de intersección de dos líneas rectas. Las dos líneas rectas trazadas se escriben como:

y1 = a1*x + b1
y2 = a2*x + b2.

Al resolver las ecuaciones anteriores obtenemos,

x0 = (b2-b1) / (a1-a2)   -(i)
y0 =a1*x0 + b1             -(ii)

De la ecuación anterior (i) y (ii) obtendremos el punto de intersección de dos líneas rectas y después de eso, el color = ‘azul noche’ se asigna al punto de intersección usando la función plot.scatter().

# import packages
import matplotlib.pyplot as plt
import numpy as np
 
# slope  and intercepts
a1, b1 = (1/4), 1.0
a2, b2 = (3/4), 0.0
 
# The numpy.linspace() function returns
# number spaces evenly w.r.t interval
l = np.linspace(-6, 6, 100)
 
# use to create new figure
plt.figure(figsize=(8, 8))
 
# plotting
plt.xlim(0, 6)
plt.ylim(0, 6)
plt.title('Plot an angle using Python')
plt.plot(l, l*a1+b1)
plt.plot(l, l*a2+b2)
 
# intersection point
x0 = (b2-b1)/(a1-a2)
y0 = a1*x0 + b1
plt.scatter(x0, y0, color='midnightblue')

Producción:

3. Trace un círculo de tal manera que el punto de intersección de dos líneas sea el mismo que el Centro del Círculo

Aquí trazamos un círculo usando la ecuación paramétrica de un círculo. La ecuación paramétrica de un círculo es:

x1= r*cos(theta)
x2=r*sin(theta)

Si queremos que el círculo no esté en el origen entonces usamos:  

x1= r*cos(theta) + h
x2=r*sin(theta) + k

Aquí h y k son las coordenadas del centro del círculo. Así que usamos esta ecuación anterior donde h =x0 yk =y0 como se muestra. Además, aquí le proporcionamos el color al círculo «azul» y su estilo está marcado como «punteado».

# import packages
import matplotlib.pyplot as plt
import numpy as np
 
# slope  and intercepts
a1, b1 = (1/4), 1.0
a2, b2 = (3/4), 0.0
 
# The numpy.linspace() function returns
# number spaces evenly w.r.t interval
l = np.linspace(-6, 6, 100)
 
# use to create new figure
plt.figure(figsize=(8, 8))
 
# plotting
plt.xlim(0, 6)
plt.ylim(0, 6)
plt.title('Plot an angle using Python')
plt.plot(l, l*a1+b1)
plt.plot(l, l*a2+b2)
 
# intersection point
x0 = (b2-b1)/(a1-a2)
y0 = a1*x0 + b1
plt.scatter(x0, y0, color='midnightblue')
 
# circle for angle
theta = np.linspace(0, 2*np.pi, 100)
r = 1.0
x1 = r * np.cos(theta) + x0
x2 = r * np.sin(theta) + y0
plt.plot(x1, x2, color='green', linestyle='dotted')

Producción:

4. Márcalo como un punto donde el círculo se cruzará con líneas rectas y marca esos dos puntos donde encontramos el ángulo entre ellos.

Ahora, encontremos los puntos donde el círculo se cruza con las dos líneas rectas. Lea los comentarios a continuación y comprenda cómo marcar puntos. Después de ese color, es decir, se proporciona el color «carmesí» donde el círculo se cruzará con dos líneas rectas. Después de eso, se proporcionan nombres a los puntos como Point_P1, Point_P2 donde encontramos el ángulo entre ellos y lo marcamos en color negro como se muestra en la salida.

# import packages
import matplotlib.pyplot as plt
import numpy as np
 
# slope  and intercepts
a1, b1 = (1/4), 1.0
a2, b2 = (3/4), 0.0
 
# The numpy.linspace() function returns
# number spaces evenly w.r.t interval
l = np.linspace(-6, 6, 100)
 
# use to create new figure
plt.figure(figsize=(8, 8))
 
# plotting
plt.xlim(0, 6)
plt.ylim(0, 6)
plt.title('Plot an angle using Python')
plt.plot(l, l*a1+b1)
plt.plot(l, l*a2+b2)
 
# intersection point
x0 = (b2-b1)/(a1-a2)
y0 = a1*x0 + b1
plt.scatter(x0, y0, color='midnightblue')
 
# circle for angle
theta = np.linspace(0, 2*np.pi, 100)
r = 1.0
x1 = r * np.cos(theta) + x0
x2 = r * np.sin(theta) + y0
plt.plot(x1, x2, color='green', linestyle='dotted')
 
 
# intersection points
x_points = []
y_points = []
 
# Code for Intersecting points of circle with Straight Lines
def intersection_points(slope, intercept, x0, y0, radius):
    a = 1 + slope**2
    b = -2.0*x0 + 2*slope*(intercept - y0)
    c = x0**2 + (intercept-y0)**2 - radius**2
 
    # solving the quadratic equation:
    delta = b**2 - 4.0*a*c  # b^2 - 4ac
    x1 = (-b + np.sqrt(delta)) / (2.0 * a)
    x2 = (-b - np.sqrt(delta)) / (2.0 * a)
 
    x_points.append(x1)
    x_points.append(x2)
 
    y1 = slope*x1 + intercept
    y2 = slope*x2 + intercept
 
    y_points.append(y1)
    y_points.append(y2)
 
    return None
 
 
# Finding the intersection points for line1 with circle
intersection_points(a1, b1, x0, y0, r)
 
# Finding the intersection points for line1 with circle
intersection_points(a2, b2, x0, y0, r)
 
# Here we plot Two points in order to find angle between them
plt.scatter(x_points[0], y_points[0], color='crimson')
plt.scatter(x_points[2], y_points[2], color='crimson')
 
 
# Naming the points.
plt.text(x_points[0], y_points[0], '  Point_P1', color='black')
plt.text(x_points[2], y_points[2], '  Point_P2', color='black')

Producción:

5. Calcula el ángulo y grafica el ángulo

En el siguiente código, se calcula el ángulo entre los puntos Point_P1 y Point_P2 y, finalmente, se traza como se muestra en la salida. 

# import packages
import matplotlib.pyplot as plt
import numpy as np
 
# slope  and intercepts
a1, b1 = (1/4), 1.0
a2, b2 = (3/4), 0.0
 
# The numpy.linspace() function returns
# number spaces evenly w.r.t interval
l = np.linspace(-6, 6, 100)
 
# use to create new figure
plt.figure(figsize=(8, 8))
 
# plotting
plt.xlim(0, 6)
plt.ylim(0, 6)
plt.title('Plot an angle using Python')
plt.plot(l, l*a1+b1)
plt.plot(l, l*a2+b2)
 
# intersection point
x0 = (b2-b1)/(a1-a2)
y0 = a1*x0 + b1
plt.scatter(x0, y0, color='midnightblue')
 
# circle for angle
theta = np.linspace(0, 2*np.pi, 100)
r = 1.0
x1 = r * np.cos(theta) + x0
x2 = r * np.sin(theta) + y0
plt.plot(x1, x2, color='green', linestyle='dotted')
 
 
# intersection points
x_points = []
y_points = []
 
# Code for Intersecting points of circle with Straight Lines
def intersection_points(slope, intercept, x0, y0, radius):
    a = 1 + slope**2
    b = -2.0*x0 + 2*slope*(intercept - y0)
    c = x0**2 + (intercept-y0)**2 - radius**2
 
    # solving the quadratic equation:
    delta = b**2 - 4.0*a*c  # b^2 - 4ac
    x1 = (-b + np.sqrt(delta)) / (2.0 * a)
    x2 = (-b - np.sqrt(delta)) / (2.0 * a)
 
    x_points.append(x1)
    x_points.append(x2)
 
    y1 = slope*x1 + intercept
    y2 = slope*x2 + intercept
 
    y_points.append(y1)
    y_points.append(y2)
 
    return None
 
 
# Finding the intersection points for line1 with circle
intersection_points(a1, b1, x0, y0, r)
 
# Finding the intersection points for line1 with circle
intersection_points(a2, b2, x0, y0, r)
 
# Here we plot Two ponts in order to find angle between them
plt.scatter(x_points[0], y_points[0], color='crimson')
plt.scatter(x_points[2], y_points[2], color='crimson')
 
 
# Naming the points.
plt.text(x_points[0], y_points[0], '  Point_P1', color='black')
plt.text(x_points[2], y_points[2], '  Point_P2', color='black')
 
 
# plot angle value
 
def get_angle(x, y, x0, y0, radius):
 
    base = x - x0
    hypotenuse = radius
 
    # calculating the angle for a intersection point
    # which is equal to the cosine inverse of (base / hypotenuse)
    theta = np.arccos(base / hypotenuse)
 
    if y-y0 < 0:
        theta = 2*np.pi - theta
 
    print('theta=', theta, ',theta in degree=', np.rad2deg(theta), '\n')
 
    return theta
 
 
theta_list = []
 
for i in range(len(x_points)):
 
    x = x_points[i]
    y = y_points[i]
 
    print('intersection point p{}'.format(i))
    theta_list.append(get_angle(x, y, x0, y0, r))
 
    # angle for intersection point1 ( here point p1 is taken)
p1 = theta_list[0]
 
# angle for intersection point2 ( here point p4 is taken)
p2 = theta_list[2]
 
# all the angles between the two intersection points
theta = np.linspace(p1, p2, 100)
 
# calculate the x and y points for
# each angle between the two intersection points
x1 = r * np.cos(theta) + x0
x2 = r * np.sin(theta) + y0
 
# plot the angle
plt.plot(x1, x2, color='black')
 
# Code to print the angle at the midpoint of the arc.
mid_angle = (p1 + p2) / 2.0
 
x_mid_angle = (r-0.5) * np.cos(mid_angle) + x0
y_mid_angle = (r-0.5) * np.sin(mid_angle) + y0
 
angle_in_degree = round(np.rad2deg(abs(p1-p2)), 1)
 
plt.text(x_mid_angle, y_mid_angle, angle_in_degree, fontsize=12)
 
# plotting the intersection points
plt.scatter(x_points[0], y_points[0], color='red')
plt.scatter(x_points[2], y_points[2], color='red')
plt.show()

Producción: