def frequencia_acumulada(histograma):
canais, valor_canal = histograma.shape[0:2]
histograma_acumulado = np.zeros((canais, valor_canal), dtype=np.int)
for cor in range(0, canais):
histograma_acumulado[cor][0] = copiar(histograma[cor][0])
for valor_pixel in range(1, valor_canal):
histograma_acumulado[cor][valor_pixel] = histograma_acumulado[cor][
valor_pixel - 1] + histograma[cor][valor_pixel]
return histograma_acumulado
def __copy__(símismo):
copia = super().__copy__()
for m in símismo.modelos.values():
copia.agregar_modelo(copiar(m))
for c in símismo.conexiones:
copia.conectar_vars(**c)
copia.conv_tiempo_dudoso = símismo.conv_tiempo_dudoso
copia.vars_clima = símismo.vars_clima
return copia
def filtro_mediana(matriz_pixels):
altura, largura = matriz_pixels.shape[0:2]
nova_matriz_pixels = np.zeros((altura, largura))
vizinhos_canais = np.zeros((1, 8))
for linha in range(1, altura - 1):
for coluna in range(1, largura - 1):
vizinhos_canais[0][0] = copiar(matriz_pixels[linha - 1][coluna -
1][0])
vizinhos_canais[0][1] = copiar(matriz_pixels[linha - 1][coluna][0])
vizinhos_canais[0][2] = copiar(matriz_pixels[linha - 1][coluna +
1][0])
vizinhos_canais[0][3] = copiar(matriz_pixels[linha][coluna - 1][0])
vizinhos_canais[0][4] = copiar(matriz_pixels[linha][coluna + 1][0])
vizinhos_canais[0][5] = copiar(matriz_pixels[linha + 1][coluna -
1][0])
vizinhos_canais[0][6] = copiar(matriz_pixels[linha + 1][coluna][0])
vizinhos_canais[0][7] = copiar(matriz_pixels[linha + 1][coluna +
1][0])
vizinhos_canais = np.sort(vizinhos_canais)
nova_matriz_pixels[linha][coluna] = copiar(vizinhos_canais[0][3])
return nova_matriz_pixels.astype('uint8')
def filtro_mediana(matriz_pixels):
altura, largura = matriz_pixels.shape[0:2]
nova_matriz_pixels = np.zeros((altura, largura, CANAIS))
vizinhos_canais = np.zeros((CANAIS, 8))
for linha in range(1, altura - 1):
for coluna in range(1, largura - 1):
for cor in range(0, CANAIS):
vizinhos_canais[cor][0] = copiar(
matriz_pixels[linha - 1][coluna - 1][cor])
vizinhos_canais[cor][1] = copiar(matriz_pixels[linha -
1][coluna][cor])
vizinhos_canais[cor][2] = copiar(
matriz_pixels[linha - 1][coluna + 1][cor])
vizinhos_canais[cor][3] = copiar(matriz_pixels[linha][coluna -
1][cor])
vizinhos_canais[cor][4] = copiar(matriz_pixels[linha][coluna +
1][cor])
vizinhos_canais[cor][5] = copiar(
matriz_pixels[linha + 1][coluna - 1][cor])
vizinhos_canais[cor][6] = copiar(matriz_pixels[linha +
1][coluna][cor])
vizinhos_canais[cor][7] = copiar(
matriz_pixels[linha + 1][coluna + 1][cor])
vizinhos_canais = np.sort(vizinhos_canais)
nova_matriz_pixels[linha][coluna][0] = copiar(
vizinhos_canais[0][3])
nova_matriz_pixels[linha][coluna][1] = copiar(
vizinhos_canais[1][3])
nova_matriz_pixels[linha][coluna][2] = copiar(
vizinhos_canais[2][3])
#biblimagem.imwrite('ruido_mediana.png', nova_matriz_pixels.astype('uint8'))
return nova_matriz_pixels.astype('uint8')
def inicializar_parametros(configuracion, partida_anterior):
"""
Función que inicializa los parámetros de la partida.
En caso de que "partida_anterior" sea distinto de None, el usuario eligió reanudar la partida anterior, por lo tanto las variables
se inicializarán con los valores correspondientes del diccionario.
Si "partida_anterior" es None, las variables se inicializarán con los valores correspondientes del diccionario "configuración".
"parametros" es un diccionario que almacena variables para controlar la lógica del juego:
parametros = {
"letra_seleccionada" : booleano que indica si el jugador seleccionó una letra de su atril,
"orientacion" : string que indica la orientación elegida para ubicar las fichas en el tablero ("horizontal" o "vertical"),
"primer_posicion" : tupla que indica la posición de la primer ficha que el usuario ubicó en el tablero,
"ultima_posicion" : tupla que indica la posición de la última ficha que el usuario ubicó en el tablero,
"jugada" : diccionario ordenado (OrderedDict) que almacena la jugada del jugador. Las claves son las posiciones del tablero
ocupadas en la jugada (tuplas) y el valor es la posición del atril de la letra ubicada en la casilla correspondiente,
"letra" : entero que indica la posición de la letra seleccionada en el atril del jugador,
"historial" : string que indica lo ocurrido durante la partida (palabras formadas, puntos, etc.),
"fichas_totales" : string que contiene todas las fichas de la bolsa ("AAABBBCC...")
"fin_juego" : booleano usado para controlar el fin de la partida
}
"tablero" es un diccionario que contine información para actualizar diferentes widgets de la ventana:
tablero = {
"posiciones_ocupadas" : diccionario que almacena todas las casillas ocupadas del tablero. Las claves son las posiciones (tupla)
y el valor es la un diccionario con la letra y su color correspondiente,
"jugador" : referencia al jugador (instancia de la clase Jugador),
"computadora" : referencia a la computadora (instancia de la clase Jugador),
"turno" : string que indica el turno ("Computadora" o "Jugador"),
"contador" : almacena la cantidad máxima de segundos de la partida,
"bolsa_de_fichas" : diccionario que almacena información sobre las fichas. Las claves son las letras y el valor es otro diccionario
que almacena el puntaje y cantidad de fichas de la letra,
"primer_jugada" : booleano que indica si se realizó alguna jugada o no,
"nivel" : string que indica el nivel de la partida ("fácil", "medio" o "difícil"),
"tamanio" : entero que indica la cantidad de filas y columnas del tablero,
"centro" : tupla que indica la posición de la casilla central del tablero,
"palabras_validas" : string que indica las palabras válidas para el nivel,
"palabras_ingresadas" : lista con las palabras ingresadas durante la partida
}
Parámetros:
- configuracion (dict): diccionario que contiene la configuración de la partida.
- partida_anterior (dict): diccionario que contiene información de la partida anterior.
Retorna:
- tablero (dict): diccionario con la información del tablero.
- parametros (dict): diccionario con párametros que controlan la lógica del juego.
"""
nivel = configuracion["nivel_seleccionado"]
configuracion = configuracion[nivel]
if not partida_anterior:
tablero = {
"posiciones_ocupadas": {},
"palabras_usadas": [],
"jugador":
Jugador(configuracion["nick"], ("white", "red")),
"computadora":
Jugador("Computadora", ("white", "orange")),
"turno":
random.choice(("Computadora", "Jugador")),
"contador":
configuracion["tiempo"] * 60,
"bolsa_de_fichas":
copiar(configuracion["fichas"]),
"primer_jugada":
True,
"nivel":
nivel,
"tamanio":
15 if nivel == "difícil" else (17 if nivel == "medio" else 19),
"centro": (7, 7) if nivel == "difícil" else
((8, 8) if nivel == "medio" else (9, 9)),
"palabras_validas":
configuracion["palabras_validas"],
"palabras_ingresadas": []
}
repartir_fichas(tablero["bolsa_de_fichas"], tablero["jugador"].fichas)
repartir_fichas(tablero["bolsa_de_fichas"],
tablero["computadora"].fichas)
else:
tablero = partida_anterior
parametros = {
"letra_seleccionada": False,
"orientacion": "",
"primer_posicion": (),
"ultima_posicion": (),
"jugada": OrderedDict(),
"letra": -1,
"historial": " Historial de la partida",
"fin_juego": False,
}
return tablero, parametros
# no tomar en cuenta la discretizacion en pixeles
# esto bien podria salir de buscar puntos de interes
XX[0] = r*np.cos(fi)+centro # posiciones en x
XX[1] = r*np.sin(fi)+centro # posisiones en y
# tengo los puntos en la imagen VCA, ahora a transformarlos y
# y ponerles ruido
XX[2],XX[3] = forwardVCA2Map(prm,XX[0],XX[1]) # con parametros optimos
# ruido=np.random.normal(0.0,s,(2,M))
#ruido de la gausiana bivaluada
ruido = np.random.multivariate_normal(mu,SS,M)
XX[2:] = XX[2:]+ruido.T
#ahora tengo los puntos listos para entrenar
prm_aux = copiar(prm) # hago una copia para modificar parametros
res = minimize(VCA2Earth_RelErr,prm_aux,args=([XX]))# optimizacion
# guardo parametros
PAR[i,:] = np.array([
prm_aux['Px'].value,
prm_aux['Py'].value,
prm_aux['Pz'].value,
prm_aux['gamma'].value,
prm_aux['beta'].value,
prm_aux['alfa'].value ])
#%% PRINT PARAMETERS
print( 'promedios y desviaciones estandar en este orden:')
print( 'px,py,pz,gamma, beta, alfa')
