Está en la página 1de 11

Gráficos tridimensionales en Matlotlib

In [26]: from IPython.display import Image
Image('http://matplotlib.org/_static/logo2.png')
Out[26]:

Matplotlib cuenta con una capacidad limitada para hacer gráficos tridimensionales empleando las rutinas
existentes para graficar en dos dimensiones.
Las capacidades para gráficos tridimensionales están encapsuladas en un "toolkit" llamado mplot3d,
que está integrado en las versiones más recientes de matplotlib. Esto significa que debemos importar
ciertas clases o funciones para generar gráficos 3D.
Lo primero es importar la clase Axes3D del modulo mpl_toolkits.mplot3d además del módulo
matplotlib.pyplot. El siguiente código se anexa al inicio de cualquier script para tal fin:
# No es necesaria si se importa p
In [2]: import matplotlib.pyplot as pyplot
from mpl_toolkits.mplot3d import Axes3D

Axes3D es una clase que no se usa directamente, pero se tiene que importar explícitamente para hacer
gráficas tridimensionales. En una libreta de Ipython como esta es cómodo importar las funciones de
numpy y de matplotlib.pyplot al espacio de nombres global, lo cual se logra usando la magia
%pylab inline.
In [1]: %pylab inline
Welcome to pylab, a matplotlib-based Python environment [backend:
module://IPython.zmq.pylab.backend_inline].
For more information, type 'help(pylab)'.
En este caso hemos cargado pylab de tal forma que las figuras creadas por matplotlib se incrusten
directamente en la libreta. Por otra parte, puede ser que pylab haya sido cargado con anterioridad, en
tal caso aparecerá un mensaje de error al ejecutar la celda anterior. Este error se puede eliminar
reiniciando el kernel de la libreta en el mmenú principal, yendo a Kernel -> Restart; cuando se ejecute
nuevamente la celda %pylab qt el error no debe aparecer más.

Gráficas de superficie

y**2 # Creando la figura.set_zlabel("Z") ax. y) : return x**2 . y0:yf:dy] Z = f(X.mplot3d import Axes3D FIGSIZE = (10. Y = mgrid[x0:xf:dx.25 X. e importada la clase Axes3D ya podemos empezar a hacer gráficas tridimensionales. Y) # De aquí en adelante todo se hace sobre atributos del objeto ``ax``. xf. Guardamos el objeto resultante en la variable ``fig` fig = figure(figsize=FIGSIZE) # Obtenemos el objeto axes de la figura. size=20) # Función de la silla de montar def f(x. dy = -20.set_ylabel("Y") ax.25 y0. 10) rc('font'. Y. Z) # Hace una gráfica de la superficie dada por ax.Una vez cargado pylab.plot_surface(X. 10. y) = x 2 − y2 In [9]: ## NOTA: ESTE CÓDIGO ASUME QUE pylab ha sido cargado previamente # Importamos la clase Axes3D from mpl_toolkits. 20.gca(projection='3d') x0. la cual es la superficie dada por la función z = f (x.set_title("Silla de montar") plt. ax. dx = -10. 0. Veamos un ejemplo completo para hacer la gráfica de la "silla de montar". lo guardamos en la varable ax # Explícitamente estamos diciendo que la proyección será 3d ax = fig. yf.set_xlabel("X") ax.show() . 0.

In [ ]: # Creando la figura. size=20) # Función de la silla de montar def f(x.mplot3d import Axes3D Primero importamos la clase Axes3D en esta línea. Por otra parte definimos la función que representa a la silla de montar. In [ ]: FIGSIZE = (10. In [ ]: from mpl_toolkits. tales como su tamaño en pulgadas y el tamaño del texto en puntos. La razón por la que definimos la variable fig es porque las funciones para graficar en 3D sólo se pueden utilizar a través de un objeto de tipo Axes3D (por eso es importante . este objeto lo guardamos en la variable fig. y) : return x**2 .y**2 En este bloque de código definimos las características de la figura. Guardamos el objeto resultante en la variable ``fig` fig = figure(figsize=FIGSIZE) En esta porción del código estamos creando una figura con el tamaño determinado por la variable FIGSIZE. 10) rc('font'. La función figure devuelve un objeto que representa a la figura completa. Estos se modifican a conveniencia nuestra.Examinemos este ejemplo.

como las etiquetas en los ejes y el título también se definen sobre nuestro objeto ax. el resultado de usar mgrid son dos matrices coordenadas. las cuales guardamos en las variables X y Y. yf.set_zlabel("Z") ax. Y = mgrid[x0:xf:dx. Y. que no es más que la función f evaluada en las matrices coordenadas X y Y. dy = -20.set_title("Silla de montar") Esta porción del código es importante.set_xlabel("X") ax. ax. La forma de hacerlo es usando el objeto mgrid.gca(projection='3d') En esta línea de código estamos accediendo al atributo gca del objeto guardado en la variable fig. dx = -10. 20. una para la variable x y otra para la variable y . Este objeto es muy intuitivo de usar. Para hacer a gráfica de la superficie se usa el atributo plot_surface del objeto ax.plot_surface(X. In [ ]: x0. el cual se crea al ejecutar la instrucción In [ ]: # Obtenemos el objeto axes de la figura. El atributo gca es una función a la cual le pasamos el argumento nombrado projection=3d para crear un objeto Axes3D. 0. xf. 10. Y) Ahora bien. Otras características de la figura. In [ ]: # De aquí en adelante todo se hace sobre atributos del objeto ``ax``. Z) # Hace una gráfica de la superficie dad ax. Después.gca es un objeto de tipo Axes3D que guardamos en la variable ax.importarlo con anterioridad). 0. mgrid cree una matriz coordenada cuyos valores estarán en el intervalo definido por las variables x0 y xf. en pasos dy. se especifica que mgrid también debe devolver otra matriz coordenada para la variable y cuyos valores estarán en el intervalo definido por y0 y yf. y0:yf:dy] Z = f(X. ya que soporta la operación de partición de listas: []. lo guardamos en la varable ax # Explícitamente estamos diciendo que la proyección será 3d ax = fig. enseguida de una coma.set_ylabel("Y") ax. El resultado de llamar a fig. para generar el dominio donde queremos graficar f (x. Color de la superficie . Así.25 y0. que es una función a la que le pasamos las tres matrices coordenadas X. en pasos dx. Y y Z. para hacer gráficas 3D trabajamos sobre el objeto ax. para la variable x . En el ejemplo anterior estamos indicando que. Su uso recuerda al de la función arange en este aspecto. y) creamos dos matrices coordenadas. De aquí en adelante cualquier acción sobre la gráfica 3D se hace sobre el objeto ax.25 X. ya que como se indico con anterioridad. Una vez que tenemos las matrices coordenadas calculamos el valor de la variable Z. necesario para las gráficas 3D.

blue.y**2 # Creando la figura. etc.plot_surface(X. Guardamos el objeto resultante en la variable ``fig` fig = figure(figsize=FIGSIZE) # Obtenemos el objeto axes de la figura. 10. 0. yf.set_title("Silla de montar") plt. lo guardamos en la varable ax # Explícitamente estamos diciendo que la proyección será 3d ax = fig. dx = -10. yellow.25 X. xf. y) : return x**2 . LOs colores aceptados son los mismos que se usan para gráficas en 2D: red. Z. green. Y.Podemos cambiar los colores de la superficie de la misma forma que en gráficas 2D: empleando la palabra clave color.set_zlabel("Z") ax. 0.mplot3d import Axes3D FIGSIZE = (10. Z.gca(projection='3d') x0.show() .set_ylabel("Y") ax.25 y0.set_xlabel("X") ax. Y) # De aquí en adelante todo se hace sobre atributos del objeto ``ax``. ax. El siguiente ejemplo lo ilustra: In [13]: ## NOTA: ESTE CÓDIGO ASUME QUE pylab ha sido cargado previamente # Importamos la clase Axes3D from mpl_toolkits. Y = mgrid[x0:xf:dx. 10) rc('font'. Y. size=20) # Función de la silla de montar def f(x. 20. dy = -20. color='green') # Gráfica de color verde ax. color='red') # Gráfica de color rojo # ax.plot_surface(X. y0:yf:dy] Z = f(X.

color='red') # Gráfica de color rojo Más alla de los colores planos podemos usar mapas de colores. Para usar un mapa de color se emplea el argumento nombrado cmap.y**2 # Creando la figura.mplot3d import Axes3D FIGSIZE = (10. Con estos mapas el color de un punto de la gráfica cambia en función de su valor. lo guardamos en la varable ax . In [ ]: ax. size=20) # Función de la silla de montar def f(x. 10) rc('font'.plot_surface(X. Y.En este ejemplo se ha pasado el argumento nombrado color='red' a la función plot_surface. El resultado es la superficie de color rojo. como se ilustra en este ejemplo: In [19]: ## NOTA: ESTE CÓDIGO ASUME QUE pylab ha sido cargado previamente # Importamos la clase Axes3D from mpl_toolkits. y) : return x**2 . Z. Guardamos el objeto resultante en la variable ``fig` fig = figure(figsize=FIGSIZE) # Obtenemos el objeto axes de la figura.

Y = mgrid[x0:xf:dx.plot_surface(X.set_ylabel("Y") ax. y0:yf:dy] Z = f(X. Z.1 y0. dy = -20. 10.# Explícitamente estamos diciendo que la proyección será 3d ax = fig. xf.set_xlabel("X") ax. cmap='gist_rainbow') # Gráfica con un mapa d ax.1 X.set_title("Silla de montar") plt. ax.gca(projection='3d') x0.show() . Y) # De aquí en adelante todo se hace sobre atributos del objeto ``ax``. 0. Y. 20. yf. dx = -10.set_zlabel("Z") ax. 0.

plot_surface(X. ax. Y. dx = -10. ax. cuyos nombres se enlistan aquí. yf. Y = mgrid[x0:xf:dx. cmap='cool') # Gráfica con un mapa de colore ax. y es una cadena de texto. y0:yf:dy] Z = f(X. Z. dy = -20.set_ylabel("Y") ax.show() . en el caso anterior. Guardamos el objeto resultante en la variable ``fig` fig = figure(figsize=FIGSIZE) # Obtenemos el objeto axes de la figura. el nombre del mapa de color es 'gist_rainbow' (con comillas).set_zlabel("Z") ax. El valor del argumento nombrado cmap es el nombre del mapa de colores. cuando cmap='gist_rainbow'. In [ ]: # De aquí en adelante todo se hace sobre atributos del objeto ``ax``.1 y0. 0. y los colores de la superficie son los del arcoiris (o algo así).set_xlabel("X") ax. xf.1 X.y**2 # Creando la figura.set_title("Silla de montar") plt. cmap='gist_rainbow') # Gráfica con un mapa d Hay muchos mapas de colores. Si usamos el mapa de colores de nombre 'cool' la superficie luce así: In [22]: ## NOTA: ESTE CÓDIGO ASUME QUE pylab ha sido cargado previamente # Importamos la clase Axes3D from mpl_toolkits. 20. size=20) # Función de la silla de montar def f(x. Z.plot_surface(X. 0. lo guardamos en la varable ax # Explícitamente estamos diciendo que la proyección será 3d ax = fig. 10) rc('font'.Como en el caso de gráficas de color plano el argumento nombrado cmap se pasa a la funcion plot_surface.mplot3d import Axes3D FIGSIZE = (10. Y) # De aquí en adelante todo se hace sobre atributos del objeto ``ax``.gca(projection='3d') x0. Y. y) : return x**2 . 10.

mplot3d import Axes3D FIGSIZE = (10. In [25]: ## NOTA: ESTE CÓDIGO ASUME QUE pylab ha sido cargado previamente # Importamos la clase Axes3D from mpl_toolkits. size=20) # Función de la silla de montar def f(x. y) : . el segundo al ángulo azimutal. La función acepta dos argumentos: el primero corresponde al ángulo de elevación. Ambos ángulos están dados en grados.Cambiar el ángulo de visualización Nuestro objeto ax tiene un atributo importante: view_init. 10) rc('font'. Este atributo es una función que nos permite definir el ángulo de visualización de la gráfica.

set_zlabel("Z") ax. Azimutal ax. Y.set_xlabel("X") ax.gca(projection='3d') x0. Y) # De aquí en adelante todo se hace sobre atributos del objeto ``ax``. Y = mgrid[x0:xf:dx. dy = -20. yf. ax. xf. dx = -10.plot_surface(X. 20.1 y0.1 X. 10. 20 # Elevación. azim_ang = 50.return x**2 . azim=azim_ang) plt.view_init(elev=elev_ang.set_ylabel("Y") ax.y**2 # Creando la figura. cmap='cool') # Gráfica con un mapa de colore ax. y0:yf:dy] Z = f(X. 0. Z. lo guardamos en la varable ax # Explícitamente estamos diciendo que la proyección será 3d ax = fig.show() . 0.set_title("Silla de montar") # Definimos los ángulos de visualización elev_ang. Guardamos el objeto resultante en la variable ``fig` fig = figure(figsize=FIGSIZE) # Obtenemos el objeto axes de la figura.

azim_ang = 50.EL ángulo de visualización se especifica en este fragmento de código: In [ ]: # Definimos los ángulos de visualización elev_ang. In [ ]: .view_init(elev=elev_ang. Se recomienda cambiar los valores de ambos ángulos para entender el efecto de los mismos. 20 # Elevación. Azimutal ax. azim=azim_ang) En este caso hemos usado un angulo de elevación de 50 grados. y un ángulo azimutal de 20 grados.