En las sesiones anteriores hemos hecho uso de algunos tipos de gráficos. En esta sesión nos ocuparemos en más detalle.

Recomendamos abrir un nuevo archivo y lo grabe con el nombre modgraficos.py.

Aquí codificaremos como funciones a cada uno de los tipos de gráficos. Desde la consola simplemente los invocaremos con solo ingresar su nombre y sin argumentos.

En este archivo nuevo, iniciaremos cargando las librerias correspondientes

import numpy as np
import matplotlib.pyplot as plt
import pylab

1. Gráfico de linea

Luego de las tres primeras líneas de import, vamos a crear la primera función llamada Linea1
def Linea1():

La siguiente línea debe quedar indentada. Respetando esta indentación escribiremos todas las instrucciones que vayamos codificando aquí. Al terminar el cuerpo de la función, se debe tener el cursor al inicio de una nueva línea. Python entenderá que allí termina la función.

Continuemos
Definimos una lista o vector:
x = [0,50]
Lo ploteamos
plt.plot(x)
plt.show()

Grabe el archivo y ejecute usando: [Run] - [Run module]. Si le pidiera grabar, haga clic en [Aeptar]
Ahora cierre la ventana del gráfico para continuar
Para trabajar en modo interactivo sin tener que estar cerrando la ventana del gfráfico, hagamos
plt.ion()
Ahora, modifique la linea del plot de la siguiente manera:
plt.plot(x,"r",label = "Linea")
Antes de la línea plt.show(), vamos a añadir nuevas acciones sobre el gráfico
plt.suptitle("Titulo principal")
plt.title("Sub titulo")
Añadimos etiquetas a los ejes
plt.xlabel("Etiqueta en el eje X")
plt.ylabel("Etiqueta en el eje Y")
Activamos la leyenda que es el label dentro del plot
plt.legend()
La siguiente linea debe contener plt.show().
Ahora ejecute el módulo.
Para ejecutarlo desde la consola, sólo digite:
>>>Linea1()

Vamos a crear la función Linea2 que graficará varias líneas

Dejando una o dos líneas como comenario (digite # al inicio de la línea para que sea comentario), crearemos la siguiente función.
def Linea2():
    x = [0,50]
    y = [0,80]
    z = [0,70]
    w = [0,200]
    plt.ion()
    plt.plot(x,"b",label="Linea 1")
    plt.plot(y,"r",label="Linea 2")
    plt.plot(z,"g",label="Linea 3")
    plt.plot(w,"m",label="Linea 4")
    plt.suptitle("Título principal")
    plt.title("Grafico de lineas")
    plt.xlabel("En el eje X")
    plt.ylabel("En el eje Y")
    plt.legend()
    plt.show()

Grabe y ejecútelo desde el módulo o desde la consola digitando: Linea2()

Derivaciones del gráfico de línea

Una o más líneas debajo de la función Linea2(), vamos a crear otra función. En esta función, vamos a graficar algunas curvas.

Primero veamos la parábola, para x>0.

linspace(0,25,50), genera 50 valores aleatorios crecientes desde 0 hasta 25.
Si no funciona linspace(), use np.linspace()

def Curvas():
x = linspace(0,25,50)
y = x**2
plot(y)
show()

Ejecute el código usando [Run] - [Run module] para grabar y generar el código
Ahora, en la consola digite: Curvas() y presione [Intro]

Cierre la ventana del gráfico para continuar

Con la misma indentación y una línea más abajo, digite el siguiente código que grafica, en la misma ventana, las funciones de seno y coseno. En cada plot se ha añadido el color, "r" y la etiquet (label = "Seno". Esta etiqueta se usará en la leyenda pues, "legend()" lo activa.
El código es:

    # Trigonométrica
    x = linspace(-pi,pi,200)
    y = sin(x)
    z = cos(x)
    plot(y,"b",label="Seno")
    legend()
    plot(z,"m",label="Coseno")
    legend()
    show()

Como en el caso anterior, gejecute grabando las modificaciones del archivo. En la consola digite Curvas()
La gráfica se muestra en la siguiente imagen

Ahora vamos a colocar dos gráficos en la misma ventana. Antes de continuar, veamos los cuadrantes en los que se puede dividir la ventana de gráficos. La imagen siguiente es muy clara al respecto.

Podemos usar un gráfico debajo de otro empleando: subplot(2,1,1) y subplot(2,1,2). Uno al costado de otro, definiendo: subplot(1,2,1) y subplot(1,2,2).

En este ejemplo vamos a trazar un gráfico debajo de otro:

Aquí el código:
   
    x = linspace(0,5,10)
    y = x**2
    subplot(1,2,1)
    plot(y,x,"r",label = "a")
    xlabel("Eje X")
    ylabel("Eje Y")
    suptitle("Titulo principal del gráfico")
    title("Subtitulo del gráfico")
    legend()
    subplot(1,2,2)
    plot(x,y,"b",label="b")
    legend()
    show()

El primer gráfico va a estar en las coordenada: (1,2,1) y (1,2,2). El primero tiene etiqueta en los ejes y el segundo no. Ambos tienen etiqueta para la leyenda y tienen colores
La siguiente imagen muestra estos gráficos.

Terminamos gráfico de línea y curva trazando dos gráficos uno incrustado en otro.

Este es el código:

    #
    # Incrustando un gráfico dentro de otro
    x = linspace(0,5,10)
    y = x**2
    fig = plt.figure()
    eje1 = fig.add_axes([0.1,0.1,0.8,0.8])
    eje2 = fig.add_axes([0.2,0.5,0.4,0.3])
    # Gráfico principal
    eje1.plot(x,y,"r")
    eje1.set_xlabel("Etiqueta en X")
    eje1.set_ylabel("Etiqueta en Y")
    eje1.set_title("Gráficos principal")
    # Gráfico en el interior
    eje2.plot(y,x,"b")
    eje2.set_xlabel("Etiqueta en Y")
    eje2.set_ylabel("Etiqueta en X")
    eje2.set_title("Gráficos incrustado")
    show()
    #
Con plt.figure() se prepara la ventana de gráfico. Con fig.add_axes(...) se define los ejes sobre los cuales se trazará las gráficas. El gráfico de x vs y  se grafica en el eje1. Para cada uno de ellos se define las etiquetas.

La siguiente imagen contiene las dos gráficas

2. Histogrma de Frecuencia

Para crear gráficos de histograma, usaremos los paquetes:

Ingrese esta líneas de import al inicio del archivo.
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as st
from pylab import *

Dejando por lo menos una línea después de la función Linea2 digite:

def Histog():
Preserve la identación automática.
Como datos usaremos los datos del archivo ahorro.txt.

Esto significa que debemos leer el archivo de datos y convertirlo en dos listas y: Ahorro y x1: Ingreso. El segmento que realiza esta conversión es:

def Histog():
    fn = open("d:\\pypage\\ahorro.txt")
    datos = fn.read().split("\n")
    fn.close()
    y =[]
    x1=[]
    for i in range(len(datos)):
        a,b =datos[i].split(",")
        y.append(float(a))
        x1.append(float(b))
    y = np.array(y)
    x1 = np.array(x1)
    g = [y,x1]
    #

Vamos a crear el histograma para la variable ahorro (y) y para la variable ingreso (x1)
Las siguientes instrucciones nos permitirá configurar el ploteo del histograma:
Capturamos el tamaño (n) de la lista y el vector bins con los datos del y para usarlo como contenedor de los valores de y. Además sólo por cuestiones de mejor presentación de las barras de y, la multiplicamos por 5, ya que algraficarlo con x1 cuyos valores son mucho mayores, las barras de x1 las van a reducir a las de y.

    n, bins = np.histogram(y)
    bins = bins*5

Con la siguiente instrucción construimos el histograma para y. Puesto que bins es una copia ordenada de menor a mayor de y, el primer argumento de hist, toma el máximo valor que estuvo en y.  Define también el color, etiqueta y los bordes de las barras que será negro.

plt.hist(bins[:-1],bins,weights=n,color="r",label="Ahorro",edgecolor="black")

Repetimos estas dos instrucciones para el caso de la variable Ingreso, x1.

    n, bins = np.histogram(x1)
    plt.hist(bins[:-1],bins,weights=n,color="b",label="Ingreso",edgecolor="black")

Ahora completamos con la definición de las etiquetas y la leyenda que actúa en la ventana del gráfico pues será la misma para las dos variables.

    xlabel('X', fontsize=10)
    ylabel('número de datos discretos', fontsize=10)
    plt.legend()
    plt.show()

Con plt.show() se mostrará el gráfico.
Grabe su archivo modgraficos.py y luego ejecútelo.
Como verá, no ocurre nada. Y no se ve resultados pues no hemos invocado a esta fución, sólo hemos convertido el archivo en "ejecutable" por el Python.
Para ver lel gráfico digitamos en la consola: Histog(), luego del cual se obtiene la gráfica que se muestra en la siguiente imagen.

3. Gráfico de barras

Un gráfico de barras es similar a un histograma en su presentación, excepto que provienen de diferentes tipos de datos. Para un histograma, se requiere de la obtención de una tabla de frecuencia. Para un gráfico de barra es suficiente la lista de datos.

Otra característica que los diferencia es que en el caso de un histograma, los datos pueden ser de 20 a más. En un gráfico de barras, cada barra es el gráfico de un valor de los datos. Si los datos tuvieran 20 valores, en un gráfico de barras tendríamos 20 barras.

Usaremos las mismas librerías que aparecen en el archivo modgraficos.py. De manera que abra el archivo y ubíquese al final dejando una o más líneas para ingresr el código de este nuevo tipo de gráfico.

La primera función se llamará miBarra1(), pues se trata de trazar un gráfico de barras para una variable ingresada desde la consola e invocarla a esta función.

Dejando una o más líneas al final del modgraficos.py, añadiremos esta función, que como va a recibir datos su cabecera será:

def miBarra1(Lista):

Cogeremos los valores de Lista para tomarlo como etiqueta del eje X, definiremos la figura en el plano, habilitaremos una ventana en las coordenadas: fila = 2, columna = 1, figura = 1 y definiremos la altura de las barras (xx):

xlab = Lista
fig = plt.figure()
pxy = fig.add_subplot(111)
xx = range(1,len(Lista)+1)

Trazamos el gráfico, primero la altura, luego los datos (Lista), definimos la amplitud de las barras (width = 0.8), el color  con la tupla (0,1,0) para el verde y lo alineamos en el centro. Por su puesto que lo mínimo necesario es la altura (xx) y los datos(Lista).

pxy.bar(xx,Lista,width=0.8,color=(0,1,0),align="center")

A continuación definimos las etiquetas tanto su contenido como su tamaño de fuente:

    pxy.set_xticks(xx)
    pxy.set_xticklabels(xlab,fontsize=6)
    pxy.set_ylabel("Etiqueta en Y",fontsize=8)
    pxy.set_xlabel("Etiqueta en X",fontsize=8)

La última instrucción, la que nos muestra el gráfico:

plt.show()

Finalmente lo grabamos y lo ejecutamos para que esté en modo ejecutable (interpretable por el Python)

En la consola definimos una lista y luego invocamos la función:
>>>y = [25,36,30,18,40,20]
>>>miBarra1(y)

El gráfico obtenido es

Ahora vamos a codificar una función (miBarras()),que trace un gráfico de barras para una variable proveniente de un archivo txt.

El archivo va a ser leído en la función. Se trata del archivo ahorro.txt que contiene dos variables. Ahorro = y, Ingreso = x1.
La función se llamará Barras(), sin argumentos. El código, excepto la lectura y generación de las dos listas y y x1, todo el resto es la misma que para el caso de miBarra1(...).
Esta función, como siempre, debe digitarla al final de todo en el archivo modgraficos.py, dejando una o más líneas.

Esta es la primera parte:

def Barras():
    fn = open("d:\\pypage\\ahorro.txt")
    datos = fn.read().split("\n")
    fn.close()
    #
    y =[]
    x1=[]
    for i in range(len(datos)):
        a,b =datos[i].split(",")
        y.append(float(a))
        x1.append(float(b))
    y = np.array(y)
    x1 = np.array(x1)
    #

Ahora preparamos la figura para los dos gráficos. Usaremos dos figuras: figure(1) y figure(2) con los planos: pxy y pxz y la misma posición de la ventana, primera fila y primera columna:

    #
    xlab = np.arange(1,len(y)+1)
    ylab = np.arange(1,len(x1)+1)
    fig1 = plt.figure(1)
    fig2 = plt.figure(2)
    pxy = fig1.add_subplot(111)
    pxz = fig2.add_subplot(111)
    xx = range(1,len(y)+1)

Ahora trazamos el gráfico para las dos variables usando xx como altura para las dos gráficas.

    pxy.bar(xx,y,width=0.8,color=(0,0,1))
    pxz.bar(xx,x1,width=0.8,color=(1,0,0))

A continuación las posiciones, etiquetas y la ejecución

    pxy.set_xticks(xx)
    pxz.set_xticks(xx)
    pxy.set_xticklabels(xlab,fontsize=6)
    pxz.set_xticklabels(ylab,fontsize=6)
    pxy.set_ylabel("En miles de soles",fontsize=8)
    pxy.set_xlabel("Valores de la variable",fontsize=8)
    plt.show()

Grabamos el archivo y lo ejecutamos para que quede en modo interpretable por Python.

Estando en la consola, digitamos: Barras() y presionamos [Intro]
Las gráficas obtenidas se muestran en la siguiente imagen.

Terminaremos con el gráfico de barras codificando una nueva función: miBarra2(Lista1, Lista2). Pues debe trazar barras para dos listas creadas en la consola.

El código es bastante similar que en el caso de miBarra1(Lista).

He aquí el código completo de esta función:

def miBarra2(Lista1,Lista2): xlab1 = Lista1 fig = plt.figure() pxy1 = fig.add_subplot(211) xx = range(1,len(Lista1)+1) pxy1.bar(xx,Lista1,width=0.8,color=(0,1,0),align="center") pxy1.set_xticks(xx) pxy1.set_xticklabels(xlab1,fontsize=6) pxy1.set_ylabel("Etiqueta en Y",fontsize=8) pxy1.set_xlabel("Etiqueta en X",fontsize=8) xlab2 = Lista2 pxy2 = fig.add_subplot(212) xx = range(1,len(Lista2)+1) pxy2.bar(xx,Lista2,width=0.8,color=(1,0,0),align="center") pxy2.set_xticks(xx) pxy2.set_xticklabels(xlab2,fontsize=6) pxy2.set_ylabel("Etiqueta en Y",fontsize=8) pxy2.set_xlabel("Etiqueta en X",fontsize=8) plt.show() Luego de digitarlo en el archivo modgraficos.py, lo grabamos y lo ejecutamos.
Para usar esta función estanto en la consola, vamos acrear dos listas:

>>> x = [10,7,25,18,12]
>>> y = [25,36,30,18,40,20]
>>> miBarra2(x,y)

La gráfica se muestra en la siguiente imagen:

4. Gráfico circular (pie)

Continuaremos con gráficos en el plano XY, presentando el proceso de creación de un gráfico circular llamado también gráfico de pie.

Abra el archivo modgraficos.py para añadir la función grfpie(...) al final y dejando algunas líneas. Como en los gráficos anteriores, haremos uso de las librerías que ya están importadas, en particular, matplotlib.pyplot que es el que usaremos conjuntamente con numpy.

La función grfpie(...) recibirá desde la consola, una lista de valores a graficar y otra lista de etiqueta para cada sector del gráfico. Y se la invocará digitando: grfpie(x, e) donde x serán los valores y e las etiquetas.

Empezamos digitando la cabecera:

def grfpie(ListaDatos,ListaEtiqueta):

Definiremos una tupla de colores que le daremos como aributo en el momento de llamar a la función que traza el gráfico: colores = ("red","green","blue","magenta","#E5D5A5","#18492D"). Observe que estamos usando dos formas diferente de listar los colores. Si sólo fueran dos, y los sectores o "slices" 4, los colores se repiten.
Ploteamos la gráfica con dos argumentos: plt.pie(ListaDatos,colors = colores).  Pero vamos a añadirle la etiqueta que lo enviamos como etiq y que aqui lo ha recibido como ListaEtiqueta: plt.pie(ListaDatos,colors = colores,labels = ListaEtiqueta).

Si deseamos que sobresalga un slice o sector, usamos una tupla de tantos ceros como sectores tendrá el gráfico. Si tuviera 4, entonces sec = (0,0.1,0,0) de forma que el segundo sector será separado. Según esto, el atributo será: explode = sec.

Del mismo modo podemos hacer que los porcentajes estén al interior de los sectores. Esto lo hacemos con: autopct = "%1.2f%%".
Si ahora queremos que el primer slice o sector se inicie en forma vertical, es decir, a los 90 grados, usamos: startangle = 90 Ya estamos listos para mostrar el gráfico.
Pero antes, como el color de relleno debe ser diferente de blanco, entonces dicho color podríamos usarlo para que cuando ponga los porcentajes al interior de los sectores, los pinte en blanco. Para ello necesitamos capturar los colores que se estén usando para activar el blanco. Esto lo hacemos con:
_,_, texto = plt.pie(ListaDatos,colors = colores,labels = ListaEtiqueta)

Como puede ver, hemos añadido antes de la instrucción de ploteo, "_,_, texto".
Ahora, por cada color del sector, debemos insertar el color blanco:
Según todo esto, plt.pie... debe quedar así:
_,_, texto = plt.pie(ListaDatos,colors = colores,labels = ListaEtiqueta, autopct = "%1.2f%%",explode=lis,startangle=90)
Para insertar el color blanco de los porcentajes:
for palabra in texto:
palabra.set_color("white")

Para que todos compartan el mismo tamaño de sector: plt.axis("equal").
Ahora colocamos el título, la leyenda que esta en ListaEtiqueta.
Antes de dar por terminado de el código, podemos hacer dos cosas:
Qutar la barra de la parte inferior del gráfico: plt.rcParams["toolbar"]="None".

Grabar el gráfico en la carpeta por omisión con: plt.savefig("prPie.png". Si se desea grabar en otro lugar, se debe introccir la ruta que incluya el nombre del archivo.

La función debe quedar así:

def grfpie(ListaDatos,ListaEtiqueta):
colores = ("red","green","blue","magenta","#E5D5A5","#18492D")
lis = (0.1,0,0,0)
plt.rcParams["toolbar"]="None"
_,_, texto = plt.pie(ListaDatos,colors = colores,labels = ListaEtiqueta,
autopct = "%1.2f%%",explode=lis,startangle=90)
for palabra in texto:
palabra.set_color("white")
plt.axis("equal")
plt.title("Grafico de sectores")
plt.legend(labels = ListaEtiqueta)
plt.show()
# Grabarlo
plt.savefig("grPie.png")

Lo grabamos y ejecutamos.
En la consola creamos la lista y le etiqueta. Supongamos que
ventas = [120,135,152,140,128,320,200]
eti = ["Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Domingo"]

Invocamos la función:
grfPie(ventas,eti)
La gráfica se muestra en la siguiente imagen

5. Gráfico de caja o BoxPlot

Continuando con los gráficos de 2D, desarrollaremos ahora el gráfico de cajas.
Un gráfico de cajas, como su nombre lo indica, muestra una caja horizontal o vertical . Tomemos una horizontal para explicar sus elementos. Hay una raya vertical que divide a la caja en dos partes. En ella se encuentra la mediana. Si esta línea no está en el centro, se dice que los datos no están distribuidos simétricamente. Si se muestra la media, podemos decidir si los datos están sesgados a la izquierda o derecha. Los extremos de la caja representan el primer y tercer cuartil. El mínimo y el máximo de los datos se muestran en los extremos de una linea a los costados de la caja, estos segmentos representan los bigotes e indican el sesgo según su longitud. Los puntos por encima o debajo de los bigotes son los datos extremos o "outliers".

Abra el archivo modgraficos.py para añadir la función respecto a estos gráficos.

La primera función se va a llamar Caja1(), sin argumentos pues la(s) listas van a estar definidas al interior.
Definimos una lista de listas pues la función .boxlot de matplotlib, requiere de una lista de listas, si se van a graficar más de una variable.
Sea Lista la lista de los datos.
Estando cargados en memoria las librerias, para a trazar el gráfico simplemente digitamos: plt.boxplot(Lista)
La función será:

def Caja1():
    d1 = [43,76,34,63,56,82,87,55,64,87,95,23,14,65,67,25,23,85,4,8]
    d2 = [34,45,34,23,43,76,26,18,24,74,23,56,23,23,34,56,32,23,28,32]
    d3 = [56,84,75,84,45,65,48,76,35,48,26,100,8,45,74,48,45,78,36,32]
    Lista = [d1,d2,d3]
    plt.boxplot(Lista)
    plt.show()

Esto se muestra en la siguiente imagen:

Vamos a cambiar la presentación, en lugar de vertical lo haremos horizontalmente que mejora la interpretación. Esto lo hacemos con: vert = False
Que muestre la media, lo que hacemos con: showmeans = True. Que cambie la forma de la caja, reduciéndose en el centro para visualiar su simetría: notch = True. Que muestre la línea de la media (con guiones): showline = True. Que muestre la caja: showbox = True
Para cambiar de color del segmento que constituye los bigotes:
lbigote = dict(color="b", alpha=0.8) La línea del boxplot debe cambiar por:
plt.boxplot(Lista,vert = False,showmeans=True,whiskerprops=lbigote,notch = False,showbox=True,meanline=True,showfliers=True)

Si se desea color de relleno de la caja, se debe definir mediante el uso de un diccionario:
bps= dict(facecolor = "cyan")
Al incluirlo en el boxplot, se de poner: boxprops = bps
El código de la función se muestra ahora:

def Caja1():
    d1 = [43,76,34,63,56,82,87,55,64,87,95,23,14,65,67,25,23,85,4,8]
    d2 = [34,45,34,23,43,76,26,18,24,74,23,56,23,23,34,56,32,23,28,32]
    d3 = [56,84,75,84,45,65,48,76,35,48,26,100,8,45,74,48,45,78,36,32]
    Lista = [d1,d2,d3]
    lbigote = dict(color="b", alpha=0.8)
    bps= dict(facecolor = "cyan")
    plt.boxplot(Lista,vert = False,showmeans=True,boxprops = bps,patch_artist = True,whiskerprops=lbigote,notch = False,showbox=True,meanline=True,showfliers=True)
    plt.show()

La gráfica se muestra en la siguiente imagen:

Como segundo gráfico de caja definimos la función Caja2()
Los datos los lee del archivo agri.txt de cuatro variables.

El código se muestra a cotinución:

def Caja2():
    fn = open("d:\\pypage\\agri.txt")
    datos = fn.read().split("\n")
    fn.close()
    #
    y =[]
    x1=[]
    x2=[]
    x3=[]
    for i in range(len(datos)):
        a,b,c,d =datos[i].split("\t")
        y.append(float(a))
        x1.append(float(b))
        x2.append(float(c))
        x3.append(float(d))
    y = np.array(y)
    x1 = np.array(x1)
    x2 = np.array(x2)
    x3 = np.array(x3)
    Lista = [y,x1,x2,x3]
    lbigote = dict(color="b", alpha=0.8)
    bps= dict(facecolor = "cyan")
    plt.boxplot(Lista,vert = False,showmeans=True,boxprops = bps,patch_artist = True,whiskerprops=lbigote,notch = False,showbox=True,meanline=True,showfliers=True)
    plt.show()


Grabar el archivo modgraficos.py con estas dos nuevas funciones y ejecutarlo para generar un código ejecutable por el Python.

Ahora, por el teclado, basta con digitar: >>>Caja2()

La imagen se muestra en la siguiente imagen

No se muestra la caja de una variable por el tamaño de los datos.

Finalmente algo respecto a los gráficos polares

Una gráfica polar se traza con dos parámetros: r que es el radio del gráfico y θ que es el ángulo del mismo.
Una vez definido estos dos parámetros, es suficiente trazar el ploteo como a cualquier otro sobre los ejes predefinidos.

En la siguiente función llamada Polares(), hemos trazado dos gráficas en la misma ventana.

Aquí la función:

def Polares():
    fig = plt.figure()
    ax = fig.add_axes([0.0, 0.0, 0.6, 0.6], polar = True)
    t = linspace(0,2*pi,100)
    r = 2*sin(3*t)
    s = 5*cos(5*t)
    ax.plot(t,r,color = "blue",lw = 5);
    ax.plot(t,s,color = "red",lw = 5);
    show()

lw = 5, permite definir el grosor de la línea de trazo y linspace genera 100 valores de 0 hasta 2*pi.

Inserte esta función al final del archivo modgraficos.py, lo graba lo ejecuta y, desde a consola, digita Polares() para tener la gráfica.

La siguiente imagen contiene esta gráfica.

En la siguiente sesión nos ocuparemos de trabajar con gráficos 3D.



Continuar en la siguiente sesión