Grficos 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 grficos tridimensionales empleando las rutinas
existentes para graficar en dos dimensiones.
Las capacidades para grficos tridimensionales estn encapsuladas en un "toolkit" llamado mplot3d,
que est integrado en las versiones ms recientes de matplotlib. Esto significa que debemos importar
ciertas clases o funciones para generar grficos 3D.
Lo primero es importar la clase Axes3D del modulo mpl_toolkits.mplot3d adems del mdulo
matplotlib.pyplot. El siguiente cdigo 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 explcitamente para hacer
grficas tridimensionales. En una libreta de Ipython como esta es cmodo 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 ms.

Grficas de superficie

Una vez cargado pylab, e importada la clase Axes3D ya podemos empezar a hacer grficas
tridimensionales. Veamos un ejemplo completo para hacer la grfica de la "silla de montar", la cual es la
superficie dada por la funcin

z = f (x, y) = x 2 y2
In [9]: ## NOTA: ESTE CDIGO ASUME QUE pylab ha sido cargado previamente
# Importamos la clase Axes3D
from mpl_toolkits.mplot3d import Axes3D

FIGSIZE = (10, 10)

rc('font', size=20)
# Funcin de la silla de montar
def f(x, y) :
return x**2 - y**2

# Creando la figura. Guardamos el objeto resultante en la variable ``fig`

fig = figure(figsize=FIGSIZE)
# Obtenemos el objeto axes de la figura, lo guardamos en la varable ax
# Explcitamente estamos diciendo que la proyeccin ser 3d
ax = fig.gca(projection='3d')
x0, xf, dx = -10, 10, 0.25
y0, yf, dy = -20, 20, 0.25
X, Y = mgrid[x0:xf:dx, y0:yf:dy]
Z = f(X, Y)
# De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z)
# Hace una grfica de la superficie dada por
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Silla de montar")
plt.show()

Examinemos este ejemplo.

In [ ]: from mpl_toolkits.mplot3d import Axes3D
Primero importamos la clase Axes3D en esta lnea.
In [ ]: FIGSIZE = (10, 10)
rc('font', size=20)
# Funcin de la silla de montar
def f(x, y) :
return x**2 - y**2

En este bloque de cdigo definimos las caractersticas de la figura, tales como su tamao en pulgadas y
el tamao del texto en puntos. Estos se modifican a conveniencia nuestra. Por otra parte definimos la
funcin que representa a la silla de montar.
In [ ]: # Creando la figura. Guardamos el objeto resultante en la variable ``fig`
fig = figure(figsize=FIGSIZE)

En esta porcin del cdigo estamos creando una figura con el tamao determinado por la variable
FIGSIZE. La funcin figure devuelve un objeto que representa a la figura completa; este objeto lo
guardamos en la variable fig. La razn por la que definimos la variable fig es porque las funciones
para graficar en 3D slo se pueden utilizar a travs de un objeto de tipo Axes3D (por eso es importante

importarlo con anterioridad), el cual se crea al ejecutar la instruccin

In [ ]: # Obtenemos el objeto axes de la figura, lo guardamos en la varable ax
# Explcitamente estamos diciendo que la proyeccin ser 3d
ax = fig.gca(projection='3d')

En esta lnea de cdigo estamos accediendo al atributo gca del objeto guardado en la variable fig. El
atributo gca es una funcin a la cual le pasamos el argumento nombrado projection=3d para crear un
objeto Axes3D, necesario para las grficas 3D. El resultado de llamar a fig.gca es un objeto de tipo
Axes3D que guardamos en la variable ax. De aqu en adelante cualquier accin sobre la grfica 3D se
hace sobre el objeto ax.
In [ ]: x0, xf, dx = -10, 10, 0.25
y0, yf, dy = -20, 20, 0.25
X, Y = mgrid[x0:xf:dx, y0:yf:dy]
Z = f(X, Y)
Ahora bien, para generar el dominio donde queremos graficar f (x, y) creamos dos matrices
coordenadas, una para la variable x y otra para la variable y . La forma de hacerlo es usando el objeto
mgrid. Este objeto es muy intuitivo de usar, ya que soporta la operacin de particin de listas: []. En el
ejemplo anterior estamos indicando que, para la variable x , mgrid cree una matriz coordenada cuyos
valores estarn en el intervalo definido por las variables x0 y xf, en pasos dx. Su uso recuerda al de la
funcin arange en este aspecto. Despus, enseguida de una coma, se especifica que mgrid tambin
debe devolver otra matriz coordenada para la variable y cuyos valores estarn en el intervalo definido
por y0 y yf, en pasos dy. As, el resultado de usar mgrid son dos matrices coordenadas, las cuales
guardamos en las variables X y Y.
Una vez que tenemos las matrices coordenadas calculamos el valor de la variable Z, que no es ms que
la funcin f evaluada en las matrices coordenadas X y Y.
In [ ]: # De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z)
# Hace una grfica de la superficie dad
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Silla de montar")

Esta porcin del cdigo es importante, ya que como se indico con anterioridad, para hacer grficas 3D
trabajamos sobre el objeto ax. Para hacer a grfica de la superficie se usa el atributo plot_surface del
objeto ax, que es una funcin a la que le pasamos las tres matrices coordenadas X, Y y Z.
Otras caractersticas de la figura, como las etiquetas en los ejes y el ttulo tambin se definen sobre
nuestro objeto ax.

Color de la superficie

Podemos cambiar los colores de la superficie de la misma forma que en grficas 2D: empleando la
palabra clave color. LOs colores aceptados son los mismos que se usan para grficas en 2D: red,
green, blue, yellow, etc. El siguiente ejemplo lo ilustra:
In [13]: ## NOTA: ESTE CDIGO ASUME QUE pylab ha sido cargado previamente
# Importamos la clase Axes3D
from mpl_toolkits.mplot3d import Axes3D

FIGSIZE = (10, 10)

rc('font', size=20)
# Funcin de la silla de montar
def f(x, y) :
return x**2 - y**2

# Creando la figura. Guardamos el objeto resultante en la variable ``fig`

fig = figure(figsize=FIGSIZE)
# Obtenemos el objeto axes de la figura, lo guardamos en la varable ax
# Explcitamente estamos diciendo que la proyeccin ser 3d
ax = fig.gca(projection='3d')
x0, xf, dx = -10, 10, 0.25
y0, yf, dy = -20, 20, 0.25
X, Y = mgrid[x0:xf:dx, y0:yf:dy]
Z = f(X, Y)
# De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z, color='red')
# Grfica de color rojo
# ax.plot_surface(X, Y, Z, color='green')
# Grfica de color verde
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Silla de montar")
plt.show()

En este ejemplo se ha pasado el argumento nombrado color='red' a la funcin plot_surface. El

resultado es la superficie de color rojo.
In [ ]: ax.plot_surface(X, Y, Z, color='red')

# Grfica de color rojo

Ms alla de los colores planos podemos usar mapas de colores. Con estos mapas el color de un punto
de la grfica cambia en funcin de su valor. Para usar un mapa de color se emplea el argumento
nombrado cmap, como se ilustra en este ejemplo:
In [19]: ## NOTA: ESTE CDIGO ASUME QUE pylab ha sido cargado previamente
# Importamos la clase Axes3D
from mpl_toolkits.mplot3d import Axes3D

FIGSIZE = (10, 10)

rc('font', size=20)
# Funcin de la silla de montar
def f(x, y) :
return x**2 - y**2

# Creando la figura. Guardamos el objeto resultante en la variable ``fig`

fig = figure(figsize=FIGSIZE)
# Obtenemos el objeto axes de la figura, lo guardamos en la varable ax

# Explcitamente estamos diciendo que la proyeccin ser 3d

ax = fig.gca(projection='3d')
x0, xf, dx = -10, 10, 0.1
y0, yf, dy = -20, 20, 0.1
X, Y = mgrid[x0:xf:dx, y0:yf:dy]
Z = f(X, Y)
# De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z, cmap='gist_rainbow')
# Grfica con un mapa d
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Silla de montar")
plt.show()

Como en el caso de grficas de color plano el argumento nombrado cmap se pasa a la funcion
plot_surface. El valor del argumento nombrado cmap es el nombre del mapa de colores, y es una
cadena de texto; en el caso anterior, cuando cmap='gist_rainbow', el nombre del mapa de color es
'gist_rainbow' (con comillas), y los colores de la superficie son los del arcoiris (o algo as).
In [ ]: # De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z, cmap='gist_rainbow')
# Grfica con un mapa d

Hay muchos mapas de colores, cuyos nombres se enlistan aqu. Si usamos el mapa de colores de
nombre 'cool' la superficie luce as:
In [22]: ## NOTA: ESTE CDIGO ASUME QUE pylab ha sido cargado previamente
# Importamos la clase Axes3D
from mpl_toolkits.mplot3d import Axes3D

FIGSIZE = (10, 10)

rc('font', size=20)
# Funcin de la silla de montar
def f(x, y) :
return x**2 - y**2

# Creando la figura. Guardamos el objeto resultante en la variable ``fig`

fig = figure(figsize=FIGSIZE)
# Obtenemos el objeto axes de la figura, lo guardamos en la varable ax
# Explcitamente estamos diciendo que la proyeccin ser 3d
ax = fig.gca(projection='3d')
x0, xf, dx = -10, 10, 0.1
y0, yf, dy = -20, 20, 0.1
X, Y = mgrid[x0:xf:dx, y0:yf:dy]
Z = f(X, Y)
# De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z, cmap='cool')
# Grfica con un mapa de colore
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Silla de montar")
plt.show()

Cambiar el ngulo de visualizacin

Nuestro objeto ax tiene un atributo importante: view_init. Este atributo es una funcin que nos permite
definir el ngulo de visualizacin de la grfica. La funcin acepta dos argumentos: el primero
corresponde al ngulo de elevacin, el segundo al ngulo azimutal. Ambos ngulos estn dados en
grados.
In [25]: ## NOTA: ESTE CDIGO ASUME QUE pylab ha sido cargado previamente
# Importamos la clase Axes3D
from mpl_toolkits.mplot3d import Axes3D

FIGSIZE = (10, 10)

rc('font', size=20)
# Funcin de la silla de montar
def f(x, y) :

return x**2 - y**2

# Creando la figura. Guardamos el objeto resultante en la variable ``fig`

fig = figure(figsize=FIGSIZE)
# Obtenemos el objeto axes de la figura, lo guardamos en la varable ax
# Explcitamente estamos diciendo que la proyeccin ser 3d
ax = fig.gca(projection='3d')
x0, xf, dx = -10, 10, 0.1
y0, yf, dy = -20, 20, 0.1
X, Y = mgrid[x0:xf:dx, y0:yf:dy]
Z = f(X, Y)
# De aqu en adelante todo se hace sobre atributos del objeto ``ax``.
ax.plot_surface(X, Y, Z, cmap='cool')
# Grfica con un mapa de colore
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Silla de montar")
# Definimos los ngulos de visualizacin
elev_ang, azim_ang = 50, 20
# Elevacin, Azimutal
ax.view_init(elev=elev_ang, azim=azim_ang)
plt.show()

EL ngulo de visualizacin se especifica en este fragmento de cdigo:

In [ ]: # Definimos los ngulos de visualizacin
elev_ang, azim_ang = 50, 20
# Elevacin, Azimutal
ax.view_init(elev=elev_ang, azim=azim_ang)
En este caso hemos usado un angulo de elevacin de 50 grados, y un ngulo azimutal de 20 grados. Se
recomienda cambiar los valores de ambos ngulos para entender el efecto de los mismos.
In [ ]: