def prueba_interactivo():
def animate(i, x, y, gf):
x.append(i)
y.append(random.randint(0, 1))
gf.g2d_graficar(0, x, y)
gf = Graficador(["0,0"], 1, 1, estilo="seaborn")
y = []
x = []
gf.set_real_time_on(animate, 1000, fargs=(x, y, gf))
def prueba_coloreado():
graficador = Graficador(["0,0"], filas=1, col=1, estilo="seaborn")
graficador.g2d_graficar(0, [1, 2, 3, 4], [1, 2, 3, 4])
graficador.set_ax_metadata__(0,
titulo="Prueba coloreado",
x_label="Eje X",
y_label="Eje Y",
x_font=25,
y_font=25)
graficador.colorear_area(0, [1, 2], [1, 2],
label="Area debajo de la curva",
posLegend="upper left")
graficador.display_graficos()
def set_de_graficos_numero_cuatro():
graficador = Graficador(["0:2,0", "2,0", "0:2,1:", "2:,1:"],
filas=3,
col=3,
estilo="seaborn")
data = np.array([
1, 2, 3, 4, 4, 5, 5, 2, 6, 2.5, 6, 5, 4, 8, -5, 4.2, 7, 8, 2.3, 12, 9,
5, 3, 4, 6, 4.3, 5.2, 5, 4, 6.8, 15
])
graficador.boxplot(0, data)
rowL = ["Mean", "varianza", "Desv_estandar", "Std_err"]
mean = round(np.mean(data), 2)
varianza = round(np.sum((data - mean)**2) / len(data), 2)
desv_estandar = round(np.sqrt(varianza), 2)
estandar_error = round(desv_estandar / np.sqrt(len(data)), 2)
celInf = [[mean], [varianza], [desv_estandar], [estandar_error]]
colLabel = ["Flores"]
graficador.tabla(1,
celInf,
rowL,
colLabel,
c_celdas="#f6f6f6",
c_rowL="#c176c8",
c_colL="#4f4f4f")
graficador.display_graficos()
def set_de_graficos_numero_dos():
graficador = Graficador(['0,0'], 1, 1, estilo=["seaborn"])
graficador.set_ax_metadata__(0,
titulo="Prueba solo un grafico",
x_label="Eje x",
y_label="Eje y")
graficador.g2d_dispersion(0, [1, 2, 3, 4], [1, 2, 3, 4])
graficador.display_graficos()
def discreto_vs_continuo():
gf = Graficador(["0,0", "0,1"], filas=1, col=2, estilo="seaborn")
gf.g2d_graficar(0, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5],
c_linea="#d16f6f",
label="Continuo")
gf.g2d_grafico_discreto(1, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5],
label="Discreto")
gf.display_graficos()
def __init__(self,Sudoku):
"""Contructor
Se Inicializa la variable del tablero para tener acceso a este y creamos un objeto de tipo graficador para poder pintar el tablero.
Parametro:
s El objeto padre de tipo Sudoku que crea a este objeto."""
self.sudoku=Sudoku
self.graficador=Graficador(self.sudoku)
self.MessageBox= ctypes.windll.user32.MessageBoxA
self.MB_ICONERROR = 0x00000010L #Critical Icon
def prueba_fechas():
dates = [
datetime(2019, 5, 24),
datetime(2019, 5, 25),
datetime(2019, 5, 26),
datetime(2019, 5, 27),
datetime(2019, 5, 28),
datetime(2019, 5, 29),
datetime(2019, 5, 30)
]
gf = Graficador(["0,0:"], filas=1, col=2, estilo="seaborn")
gf.g2d_grafico_discreto(0, dates, [4, 5, 3, 5, 6, 3, 5], baseline=False)
gf.format_date_axis(0)
gf.display_graficos()
def prueba_matriz_confusion_con_categorias():
gf = Graficador(["0,0"], filas=1, col=1, estilo="seaborn")
matriz = np.array([[25, 0, 0, 0, 0], [2, 30, 1, 0, 0], [1, 0, 45, 0, 5],
[0, 0, 2, 62, 4], [1, 0, 3, 0, 29]])
gf.matriz_de_confusion(
0,
matriz,
labels_categorias=["Gato", "Perro", "Cerdo", "Caballo", "Vaca"])
gf.display_graficos()
def prueba_contornos():
gf = Graficador(["0:,0", "0:,1"], filas=2, col=2, estilo="seaborn")
X = np.array([1, 2, 3, 4, 5])
Y = np.array([1, 2, 3, 4, 5])
Z = np.zeros(shape=(X.shape[0], Y.shape[0]))
Z[0, 0] = 5
Z[1, 1] = 5
Z[2, 2] = 5
Z[2, 2] = 5
Z[3, 3] = 5
gf.g2d_contour(0, X, Y, Z, niveles=5, display_level=False, fcontour=False)
gf.display_graficos()
def tabla_interactiva():
def animate(i, graficador):
def turn_white_and_black(vector):
return ["#4f4f4f" if x < 0.5 else "#f6f6f6" for x in vector]
def turn_blank(vector):
return ["" for _ in vector]
matrix = np.random.rand(5, 5)
black_and_white_matrix = np.array(
list(map(turn_white_and_black, matrix)))
empty_string_matrix = np.array(np.array(list(map(turn_blank, matrix))))
graficador.tabla(0,
empty_string_matrix,
c_celdas=black_and_white_matrix)
graficador = Graficador(["0,0"], filas=1, col=1, estilo="seaborn")
graficador.set_real_time_on(animate, 4000, fargs=[graficador])
graficador.display_graficos()
def set_de_graficos_uno():
#Instancio clase
graficador = Graficador(['0,0', '0,1', '0,2'], 1, 3, estilo=["seaborn"])
#Realizo Grafico Uno
graficador.set_ax_metadata__(0,
titulo="Combinacion graficos",
x_label="Eje x",
y_label="Eje y")
graficador.g2d_graficar(0, [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6],
estilo_linea="dotted",
label="Dotted line",
posLegend="upper left")
graficador.g2d_graficar(0, [1, 2, 3, 4, 5, 6], [6, 5, 4, 3, 2, 1],
label="Solid line",
posLegend="upper center")
#Realizo Grafico Dos
graficador.set_ax_metadata__(1, titulo="Histograma")
graficador.histograma(1, [1, 1, 2, 3, 2, 5, 6, 2, 1.5, 6, 4])
#Realizo Grafico Tres
graficador.set_ax_metadata__(2,
titulo="Histograma conjunto",
x_label="Eje x",
y_label="Eje y",
x_font=24,
y_font=24)
graficador.histograma_conjunto(2, [1, 1, 2, 3, 2, 5, 6, 2, 1.5, 6, 6],
[1, 3, 3, 2, 1, 3, 6, 8, 4, 5, 6, 4, 1, 2],
label=["H1", "H2"])
#Hago un display de los graficos
graficador.display_graficos()
def set_de_graficos_numero_tres():
# #Instancio clase
graficador = Graficador(['0,0', '0,1:', '1,0', '1,1:'],
2,
3,
estilo=["seaborn"])
#Realizo grafico numero uno
graficador.set_ax_metadata__(0, titulo="Prueba Opaquidad")
graficador.g2d_graficar(0, [1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6],
opaquez=0.77,
c_marker="red",
label="Aproximation",
posLegend="upper left")
graficador.g2d_dispersion(0, [1, 2, 3, 4, 5, 6],
[1.2, 2.2, 2.8, 3.7, 5.1, 6],
s=45,
opaquedad=0.8,
posLegend="upper left",
label="Real")
#Realizo grafico numero dos
graficador.set_ax_metadata__(1, titulo="Grafico tarta")
graficador.grafico_tarta(1, [21321, 15689, 26500],
labels=["Perros", "Loros", "Tortugas"],
anchoLinea=3,
colores=["#624848", "#394f35", "#f45ddc"],
sombra=True,
d_valores=True,
s_destacar="max",
angulo_inicio=90)
#Realizo grafico numero tres
graficador.g2d_barras(2, [1, 2, 3, 4, 5], [20, 50, 70, 50, 20],
label="Barras")
graficador.set_ax_metadata__(2, titulo="Grafico barras")
graficador.set_ax_ticks(2,
x_ticks=[1, 2, 3, 4, 5],
x_labels=[15, 20, 25, 30, 35])
graficador.dibujar_linea(2, 23, 0.2, 1, label="Prueba linea horizontal")
#Realizo grafico numero cuatro
graficador.g2d_barras(3, [1, 2, 3, 4, 5], [20, 50, 70, 50, 20],
pos_barras="horizontal",
label="Barras")
graficador.set_ax_metadata__(3, titulo="Grafico barras horizontal")
graficador.set_ax_ticks(3,
y_ticks=[1, 2, 3, 4, 5],
y_labels=[15, 20, 25, 30, 35])
graficador.dibujar_linea(3,
2,
0.2,
0.8,
orientacion="vertical",
label="Prueba linea vertical")
#Hago un display de los graficos
graficador.display_graficos()
from main import Juego
from graficador import Graficador
g = Graficador()
piezas = 7
miJuego = Juego(piezas)
miJuego.setGraficador(g)
g.graf(miJuego)
miJuego.mover(piezas, 0)
while(1):
g.graf(miJuego)
def prueba_grafico_por_imagen2():
gf = Graficador(["0:2,0:", "2:,0:"], filas=4, col=4, estilo="seaborn")
gf.graficar_imagen_por_ruta(0, "/home/juan/Downloads/feedfw.png")
gf.graficar_imagen_por_ruta(1, "/home/juan/Downloads/cnn.jpeg")
#/ home / juan / Downloads
gf.display_graficos()
def prueba_grafico_por_imagen():
gf = Graficador(["0:,0:"], filas=2, col=2, estilo="seaborn")
gf.graficar_imagen_por_ruta(0, "/home/juan/Downloads/feedfw.png")
#/ home / juan / Downloads
gf.display_graficos()
def prueba_matriz_confusion_sin_categorias():
gf = Graficador(["0,0"], filas=2, col=2, estilo="seaborn")
matriz = np.array([[25, 0, 0, 0, 0], [2, 30, 1, 0, 0], [1, 0, 45, 0, 5],
[0, 0, 2, 62, 4], [1, 0, 3, 0, 29]])
gf.matriz_de_confusion(0, matriz)
gf.display_graficos()
class Validador:
def __init__(self,Sudoku):
"""Contructor
Se Inicializa la variable del tablero para tener acceso a este y creamos un objeto de tipo graficador para poder pintar el tablero.
Parametro:
s El objeto padre de tipo Sudoku que crea a este objeto."""
self.sudoku=Sudoku
self.graficador=Graficador(self.sudoku)
self.MessageBox= ctypes.windll.user32.MessageBoxA
self.MB_ICONERROR = 0x00000010L #Critical Icon
def Relacionar(self):
"""Pasa de la imagen de la ficha a un entero que corresponde al numero de la imagen."""
self.sudoku.numeros=[]
for i in range(9):
n=[]
for j in range(9):
n.append(int(self.sudoku.cajas[i][j].accessibleName()))
self.sudoku.numeros.append(n)
def ValidarEspaciosVacios(self):
"""Verifica si el en tablero hay algun espacio vacio
Retorna: 1 -> Completo , 0 -> Incompleto."""
for i in range(9):
for j in range(9):
if self.sudoku.numeros[i][j]==0:
return 0
return 1
def SubCuadros(self):
"""Extrae la subcuadricula en la que se va a buscar algun posible numero repetido.
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos"""
contador = 0
self.sudoku.subnumeros=[]
for i in range(3):
self.sudoku.subnumeros.append([0]*3)
#Primer SubCuadro
for i in range(3):
for j in range(3):
self.sudoku.subnumeros[i][j] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(0, 0)
#Segundo SubCuadro
for i in range(3):
for j in range(3,6):
self.sudoku.subnumeros[i][j-3] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(0, 3)
#Tercer SubCuadro
for i in range(3):
for j in range(6,9):
self.sudoku.subnumeros[i][j-6] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(0, 6)
#Cuarto SubCuadro
for i in range(3,6):
for j in range(3):
self.sudoku.subnumeros[i-3][j] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(3, 0)
#Quinto SubCuadro
for i in range(3,6):
for j in range(3,6):
self.sudoku.subnumeros[i-3][j-3] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(3, 3)
#Sexto SubCuadro
for i in range(3,6):
for j in range(6,9):
self.sudoku.subnumeros[i-3][j-6] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(3, 6)
#Septimo SubCuadro
for i in range(6,9):
for j in range(3):
self.sudoku.subnumeros[i-6][j] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(6, 0)
#Octavo SubCuadro
for i in range(6,9):
for j in range(3,6):
self.sudoku.subnumeros[i-6][j-3] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(6, 3)
#Noveno SubCuadro
for i in range(6,9):
for j in range(6,9):
self.sudoku.subnumeros[i-6][j-6] = self.sudoku.numeros[i][j]
contador = contador + self.VerificarSubCuadro()
if not(self.VerificarSubCuadro()):
self.graficador.pintaSub(6, 6)
if contador == 9:
return 1
return 0
def VerificarSubCuadro(self):
"""Valida que no existan numeros repetidos en la subcuadricula.
En caso de haber algun numero repetido en la subcuadricula, se pinta dicha subcuadricula.
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos"""
for i in range(3):
for j in range(3):
numero = self.sudoku.subnumeros[i][j]
if numero != 0:
for k in range(3):
for l in range(3):
if i != k or j != l:
if numero == self.sudoku.subnumeros[k][l]:
return 0
return 1
def ValidarX(self):
"""Recorre el tablero linea a linea para encontrar numeros repetidos
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos."""
b = 1
for i in range(9):
b = self.ValidaLinea(i)
if b == 0:
self.graficador.pintaX(i)
return 0
return 1
def ValidaLinea(self,i):
"""Busca en la linea i si existe algun numero repetido.
Parametro: i Linea donde se buscara.
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos."""
fichas=[0]*10
for j in range(9):
indice = self.sudoku.numeros[i][j]
fichas[indice] = fichas[indice] + 1
return self.VerificaArregloIndices(fichas)
def ValidarY(self):
"""Recorre el tablero columna a columna para encontrar numeros repetidos
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos."""
b = 1
for j in range(9):
b = self.ValidaColumna(j)
if b == 0:
self.graficador.pintaY(j)
return 0
return 1
def ValidaColumna(self,j):
"""Busca en la columna j si existe algun numero repetido.
Parametro: j Columna donde se buscara.
Retorna: Valor: 1 -> Correcto , 0 -> Existen numeros repetidos."""
fichas=[0]*10
for i in range(9):
indice = self.sudoku.numeros[i][j]
fichas[indice] = fichas[indice] + 1
return self.VerificaArregloIndices(fichas)
def VerificaArregloIndices(self,fichas):
"""Verifica el numero de veces que se repite un numero.
Si algun numero se repite mas de una vez, entonces existe algun repetido.
Parametro: fichas Numero de ocurrencias de cada numero.
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos."""
for i in range(1,10):
if fichas[i] > 1:
return 0
return 1
def Validaciones(self):
"""Maneja todas las validaciones y muestra un mensaje al usuario de acuerdo al tipo de error.
Retorna: 1 -> Correcto , 0 -> Existen numeros repetidos."""
b=1
if not(self.sudoku.invalida):
return 1
if not(self.ValidarX()):
self.MessageBox(None,"Existen Numeros Repetidos En Las Filas..!","ERROR",self.MB_ICONERROR)
self.graficador.pintaTablero()
b=0
if not(self.ValidarY()):
self.MessageBox(None,"Existen Numeros Repetidos En Las Columnas..!","ERROR",self.MB_ICONERROR)
self.graficador.pintaTablero()
b=0
if not(self.SubCuadros()):
self.MessageBox(None,"Existen Numeros Repetidos En Las Sub-Cuadriculas..!","ERROR",self.MB_ICONERROR)
self.graficador.pintaTablero()
b=0
return b
s = list()
for i in range(0,n):
s.append( str(a[i])+"+" + str(b[i])+"*(x-"+str(x[i])+")+"+\
str(c[i])+"*(x-"+ str(x[i]) +")**2+"+str(d[i])+\
"*(x-"+ str(x[i])+ ")**3")
# s.append(str(a[i]) \
# + " + np.multiply(" + str(b[i]) + ", np.add(x, -" + str(x[i]) + "))"
# + " + np.multiply(" + str(c[i]) + ", np.power(np.add(x, -" + str(x[i]) + "), 2))" \
# + " + np.multiply(" + str(d[i]) + ", np.power(np.add(x, -" + str(x[i]) + "), 3))")
#print(s[i])
#plt.plot(x, eval(s[i]))
inter = list()
for i in range(0,len(x)-1):
inter.append((x[i],x[i+1]))
#plt.plot(s,inter)
#print("a: ", a)
#print("b: ", b)
#print("c: ", c)
#print("d: ", d)
print("s: ", s)
return a, b, c, d, s
canvas = Graficador(3000, 3000, 30)
a0, b0, c0, d0, s0 = spline([1,2,5,6,7,8,10,13,17] ,[3.0,3.7,3.9,4.2,5.7,6.6,7.1,6.7,4.5],8,1.0,-0.67)
a1, b1, c1, d1, s1 = spline([17,20,23,24,25,27,27.7],[4.5,7.0,6.1,5.6,5.8,5.2,4.1],6,3.0,-4.0)
a2, b2, c2, d2, s2 = spline([27.7,28,29,30],[4.1,4.3,4.1,3.0],3,0.33,-1.5)
s = s0 + s1 + s2
canvas.graficar(s, 0, 31)
plt.show()
class FruchtermanReingold:
def __init__(self, grafo, iters, refresh, c1, c2, verbose):
'''
Parámetros:
* iters: cantidad de iteraciones a realizar.
* refresh: numero de iteraciones entre actualizaciones de
pantalla, si vale 1, se grafica solo al final.
* c1: constante usada para calcular la repulsión entre nodos.
* c2: constante usada para calcular la atracción de aristas.
* verbose: si vale true, el programa imprimirá información
adicional a medida que corre.
'''
# Guardo grafo
self.grafo = grafo
# Guardo opciones
self.iters = iters
self.verbose = verbose
self.refresh = refresh
self.c1 = c1
self.c2 = c2
# Inicializo estado
self.posiciones = {}
def randomize_node_positions(self):
'''Randomiza las posiciones de los nodos'''
nodos = self.grafo[0]
for node in nodos:
x = self.W * random()
y = self.H * random()
self.posiciones[node] = Vector(x, y)
def repulsion(self, d):
'''Calcula la fuerza de repulsión dada la distancia'''
return self.c1 * self.k**2 / d
def atraccion(self, d):
'''Calcula la fuerza de atracción dada la distancia'''
return self.c2 * d**2 / self.k
def step(self):
'''
Efectúa un paso de la simulación, actualizando posiciones
de los nodos
'''
nodes = self.grafo[0]
edges = self.grafo[1]
despl = {}
# 1: Calcular repulsiones de nodos (actualiza fuerzas)
for u in nodes:
despl[u] = Vector(0, 0)
for v in nodes:
if u == v:
continue
delta = self.posiciones[u] - self.posiciones[v]
dist = delta.longitud()
if dist != 0:
d = self.repulsion(dist) / dist
despl[u] = (despl[u] + delta * d)
# 2: Calcular atracciones de aristas (actualiza fuerzas)
for u, v in edges:
delta = self.posiciones[u] - self.posiciones[v]
dist = delta.longitud()
if delta != 0:
d = self.atraccion(dist) / dist
dd = delta * d
despl[u] = (despl[u] - dd)
despl[v] = (despl[v] + dd)
# 4: En base a fuerzas, temperatura y bordes, actualizar
# las posiciones de los nodos.
cnt = 0
for node in nodes:
delta = despl[node]
dist = delta.longitud()
if dist != 0:
cnt = cnt + 1
d = min(dist, self.t) / dist
npos = self.posiciones[node] + delta * d
self.posiciones[node].x = min(self.W, max(0, npos.x))
self.posiciones[node].y = min(self.H, max(0, npos.y))
self.t -= self.dt
def create_view(self):
'''Inicializa el graficador'''
self.graficador = Graficador(800, 600)
def dibujar(self):
'''Dibuja el grafo mediante el graficador'''
self.graficador.dibujar_grafo(self.grafo, self.posiciones)
def run(self):
'''
Ejecuta los pasos del algoritmo, de acuerdo a los argumentos
con los cuales se inicializó la clase.
'''
# Inicializamos constantes
nodes = self.grafo[0]
self.W = 1
self.H = 1
self.area = self.W * self.H
self.k = math.sqrt(self.area / len(nodes))
self.t = self.W / 10
self.dt = self.t / (self.iters + 1)
# Inicializamos la 'pantalla'
self.create_view()
# Inicializamos las posiciones
self.randomize_node_positions()
# Si es necesario, lo mostramos por pantalla
if (self.refresh > 0):
self.dibujar()
# Bucle principal
for i in range(0, self.iters):
# Realizar un paso de la simulacion
self.step()
if i % 20 == 0 and self.verbose:
print('Temperatura: ' + str(self.t))
# Si es necesario, lo mostramos por pantalla
if (self.refresh > 0 and i % self.refresh == 0):
self.dibujar()
# Ultimo dibujado al final
self.dibujar()
# Solo al final, permitimos que el usuario cierre la ventana
self.graficador.permitir_cerrado()
def create_view(self):
'''Inicializa el graficador'''
self.graficador = Graficador(800, 600)