def CalcularCA(self):
distancia = None
p11 = self.Usuario1.text()
p22 = self.Usuario2.text()
if (self.objetoClaseRecomender.ususarioExiste(p11) == -1):
self.textEdit.setText("El usuario " + p11 + " no existe")
return
#RatingcomputeSimilar('1', 'Toy Story (1995)',listaNombresBD, userRatings)
if (self.CosenoAjustado.isChecked() and self.tipeBase == 0):
distancia = fl.RatingCosenoAjustado(
p11, p22, self.objetoClaseRecomender.data)
self.textEdit.setText(str(distancia))
if (self.CosenoAjustado.isChecked() and self.tipeBase == 1):
print("Patrick C")
distancia = fl.RatingCosenoAjustado(
p11, p22,
self.objetoClaseRecomender.self.objetoClaseRecomender.data)
self.textEdit.setText(str(distancia))
if (self.CosenoAjustado.isChecked() and self.tipeBase == 4
or self.tipeBase == 3):
distancia = fl.RatingCosenoAjustado(
p11, p22, self.objetoClaseRecomender.data)
self.textEdit.setText(str(distancia))
def imprimirResumoKM(linhas_todos_km):
cont = 0
try:
cadencias = obterCadenciasKM(linhas_todos_km)
except:
pass
print(10 * "-" + "Resumo dos KM" + 10 * "-")
for x in linhas_todos_km:
cont += 1
print(str(cont) + "º KM:")
print("Tempo:", Distancias.obterDuracao(x))
print("Ritmo: {:.2f} mins/km".format(Distancias.obterRitmoMedio(x)))
try:
print("Cadência de Passos: {} passos/min".format(
int(cadencias[cont - 1])))
except:
pass
try:
print("Média de BPM: {:.1f}".format(
Distancias.calcularMediaBPM(x)))
except:
pass
try:
var_status, var_altitude = variacaoAltitude(linhas_todos_km)
if var_status[cont - 1] == "- - -":
print("Altitude: {}".format(var_status[cont - 1]))
else:
print("Altitude: {} {:.2f}m".format(
var_status[cont - 1], abs(var_altitude[cont - 1])))
except:
pass
print()
def obterRitmoLap(x):
distancia, lista_distancias = Distancias.calculaDistancia(
Distancias.obterAngulos(x))
duracao = tempoLap(x)
duracao_min = Time.ConverterDuracaoMinuto(duracao)
ritmo = duracao_min / distancia
return ritmo
def loadMovieLens27m(self):
self.data = {}
self.productid2name = {}
print("________________")
self.data = fl.CargarBinario("movilens27k_data")
print("________________")
self.productid2name = fl.CargarBinario("movilens27k_productid2name")
self.listaNombresBD = fl.CargarBinario("movielens27k_namePeliculas")
print("fin de carga de la data")
def loadMovieRating(self):
self.data = {}
self.productid2name = {}
self.listaNombresBD = []
print("________________")
self.data = fl.CargarBinario("Movie_Ratings")
self.listaNombresBD = fl.CargarBinario("Movie_Ratings_namePeliculas")
#print(self.listaNombresBD)
print("________________")
def loadMovieLensN(self):
self.data = {}
self.productid2name = {}
print("________________")
self.data = fl.CargarBinario("movilens1k_data")
self.productid2name = fl.CargarBinario("movilens1k_productid2name")
self.listaNombresBD = fl.CargarBinario("movielens_namePeliculas")
print(self.listaNombresBD)
print("________________")
def imprimirResumoTotal(linhas_arq):
distancia_total, lista_distancias = Distancias.calculaDistancia(
Distancias.obterAngulos(linhas_arq))
print(4 * "-" + "Resumo Total da Atividade" + 4 * "-")
print("Distância Total: {:.4f}km".format(distancia_total))
print("Tempo Total:", Distancias.obterDuracao(linhas_arq))
print("Ritmo Médio: {:.2f} mins/km ".format(
Distancias.obterRitmoMedio(linhas_arq)))
try:
lista_bpm = Distancias.obterBPM(linhas_arq)
print("Média de BPM: {:.1f}".format(
Distancias.calcularMediaBPM(linhas_arq)))
print("BPM Máxima:", max(lista_bpm))
print("BPM Mínimo:", min(lista_bpm))
except Exception as e:
#print(str(e))
pass
try:
print("Cadência de Passos: {} passos/min".format(
int(Distancias.obterCadencia(linhas_arq))))
except:
pass
try:
lista_altitude = Distancias.obterAltitudes(linhas_arq)
print("Altitude Máxima: {:.2f}m".format(max(lista_altitude)))
print("Altitude Mínima: {:.2f}m".format(min(lista_altitude)))
except:
pass
def obterCadenciasKM(lista_todos_km):
inicial = 0
lista_cadencias = []
for x in lista_todos_km:
final = Distancias.obterUltimoPasso(x)
passos = final - inicial
inicial = final
duracao = Distancias.obterDuracao(x)
duracao_min = Time.ConverterDuracaoMinuto(duracao)
lista_cadencias.append(passos / duracao_min)
return lista_cadencias
def GraficoPercurso(linhas_arq):
coord, posicoes = Distancias.obterCoordenadas(linhas_arq)
coordX = []
coordY = []
for x, y in coord:
coordX.append(x / 5)
coordY.append(y / 5)
coordX = transladarPontos(coordX, max(coordX))
coordY = transladarPontos(coordY, max(coordY))
turtle.screensize(max(coordX) + 50, max(coordY) + 50)
turtle.title("Percurso")
Yeojin = turtle.Turtle()
Yeojin.color("#FF4500")
Yeojin.write("Início", font=("Arial", 9, "normal"))
Yeojin.color("#4B0082")
Yeojin.shape("circle")
Yeojin.shapesize(0.3)
Yeojin.hideturtle()
Yeojin.penup()
Yeojin.goto(coordX[0], coordY[0])
Yeojin.pendown()
for x in range(len(coordX) - 1):
Yeojin.goto(coordX[x], coordY[x])
if x in posicoes:
Yeojin.color("#FF4500")
Yeojin.stamp()
Yeojin.color("#4B0082")
Yeojin.write("Fim", font=("Arial", 9, "normal"))
def calcularKM(linhas_arq):
dis_total, lista_dis = Distancias.calculaDistancia(
Distancias.obterAngulos(linhas_arq))
soma_dis = lista_dis[0]
ultima_dis = abs(1 - soma_dis)
km = []
posicoes = []
for pos, x in enumerate(lista_dis[1:]):
soma = soma_dis + x
if ultima_dis < abs(1 - soma):
km.append(soma_dis)
posicoes.append(pos + 1)
soma_dis = x
ultima_dis = abs(1 - soma_dis)
else:
soma_dis += x
ultima_dis = abs(1 - soma_dis)
km.append(soma_dis)
return posicoes
def imprimirResumoLap(linhas_todos_laps):
cont = 0
print(9 * "-" + "Resumo dos Laps" + 9 * "-")
for x in linhas_todos_laps:
cont += 1
lista_bpm = Distancias.obterBPM(x)
lista_ts = obterTimestamp(x)
print(str(cont) + "º Lap:")
print("Tempo:", tempoLap(x))
print("Ritmo: {:.2f} mins/km".format(obterRitmoLap(x)))
try:
maximo = max(lista_bpm)
minimo = min(lista_bpm)
print("BPM Máximo: {} às {}".format(
maximo, horaBPM(lista_ts, lista_bpm, maximo)))
print("BPM Mínimo: {} às {}".format(
minimo, horaBPM(lista_ts, lista_bpm, minimo)))
print("Média de BPM: {:.1f}".format(
Distancias.calcularMediaBPM(x)))
except:
pass
print()
def IniciarConsultaDistancia(self):
texto = 0
distancia = None
p11 = self.Usuario1.text()
p22 = self.Usuario2.text()
rr1 = self.r_minkowski.text()
if (self.objetoClaseRecomender.ususarioExiste(p11) == -1):
self.textEdit.setText("El usuario " + p11 + " no existe")
return
if (self.objetoClaseRecomender.ususarioExiste(p22) == -1):
self.textEdit.setText("El usuario " + p22 + " no existe")
return
print("p22 = ", self.objetoClaseRecomender.data[p22])
p1 = self.objetoClaseRecomender.data[p11]
p2 = self.objetoClaseRecomender.data[p22]
if (self.DistanciaE.isChecked()):
distancia = fl.distanciaEuclidiana(p1, p2)
if (self.DistanciaM.isChecked()):
distancia = fl.distanciaManhattan(p1, p2)
if (self.Minkowski.isChecked()):
distancia = fl.DistancaMinkowski(p1, p2, rr1)
if (self.DistanciaC.isChecked()):
distancia = fl.similitudCoseno_(p1, p2)
if (self.Pearson.isChecked()):
distancia = fl.pearson(p1, p2)
if (self.Jaccard.isChecked()):
distancia = fl.jaccard_distance(p1, p2)
if (self.CosenoAjustado.isChecked()):
texto = 1
distancia = fl.computeSimilarity(
self.objetoClaseRecomender.listaNombresBD,
self.objetoClaseRecomender.data)
if (texto == 1):
self.textEdit.clear()
for i, x in distancia.items():
pair = None
self.textEdit.append(i)
for j, l in x.items():
pair = "\t" + str(j) + " " + str(l)
self.textEdit.append(pair)
else:
self.textEdit.setText(str(distancia))
def variacaoAltitude(listas_todos_km):
var_altitude = []
var_status = []
for pos, x in enumerate(listas_todos_km):
atual = Distancias.obterAltitudes(x)[-1]
if pos == 0:
var_altitude.append(0)
var_status.append("- - -")
else:
diferenca = atual - anterior
var_altitude.append(diferenca)
if diferenca < 0:
var_status.append("diminuiu")
elif diferenca > 0:
var_status.append("aumentou")
else:
var_status.append("- - -")
anterior = atual
return var_status, var_altitude
if Nombre in userRatings:
currentRatings = userRatings[Nombre]
else:
currentRatings = {}
currentRatings[Item] = rating
userRatings[Nombre] = currentRatings
if __name__ == "__main__":
#Movie_Ratings
#Book_data
#movilens1k_data
#Book_data
userRatings = fl.CargarBinario("Movie_Ratings")
MeterUsuario("Jose", {
"Alien": 2,
"Avatar": 4,
"Jaws": 8,
"Scarface": 1,
"Village": 5
})
p = recommender(userRatings)
user = "******"
peli = "Village"
p.computeDeviations2(user, peli)
p.slopeOneRecommendations2(user, "")
#sss = fl.CargarBinario("Book_data")
def GraficoSobreposicao(linhas_arq):
tempo = calculaTempo(Distancias.obterTempos(linhas_arq))
lst = []
try:
bpm = Distancias.obterBPM(linhas_arq)
b = "b - BPM"
z = "z - Zonas de BPM"
lst.append(max(bpm))
except:
b = ""
z = ""
try:
alt = Distancias.obterAltitudes(linhas_arq)
a = "a - Altitude"
lst.append(max(alt))
except:
a = ""
rit = Distancias.obterListaRitmo(linhas_arq)
tempo_sem_transladar = tempo
tempo = [x / 3 for x in tempo]
tempo = transladarPontos(tempo, 500 - 20)
Chuu = turtle.Turtle()
Chuu.penup()
Chuu.hideturtle()
Chuu.goto(tempo[0], -40)
lst.append(max(rit))
global tela
tela = turtle.Screen()
turtle.screensize(max(tempo) + 50, max(lst) + 1000)
op = tela.textinput(
"Gráficos",
"Quais gráficos deseja visualizar?\n\np - Percurso\n{}\n\nOu combine:\n{}\n{}\nr - Ritmo\n\n"
.format(z, a, b))
while op != None:
if op == "z":
GraficoZonas(bpm, tempo, tempo_sem_transladar)
if op == "p":
GraficoPercurso(linhas_arq)
if "b" in op or "a" in op or "r" in op:
Chuu.write("Legenda:", font=("Arial", 9, "normal"))
desenharEixo(lst, tempo, "", "Tempo")
numerarEixoX(tempo_sem_transladar, tempo)
numerarEixoY(lst, tempo)
if "b" in op:
Chuu.color("red")
Chuu.goto(tempo[0], -80)
Chuu.write("BPM", font=("Arial", 10, "normal"))
Grafico(bpm, tempo, "red")
if "a" in op:
Chuu.color("#006400")
Chuu.goto(tempo[0], -120)
Chuu.write("Altitude", font=("Arial", 10, "normal"))
Grafico(alt, tempo, "#006400")
if "r" in op:
Chuu.color("purple")
Chuu.goto(tempo[0], -160)
Chuu.write("Ritmo", font=("Arial", 10, "normal"))
Grafico(rit, tempo, "purple")
else:
erro = "Opção Inválida.\n"
op = tela.textinput(
"Gráficos",
"{}Quais gráficos deseja visualizar?\n\np - Percurso\n{}\n\nOu combine:\n{}\n{}\nr - Ritmo\n\n"
.format(erro, z, a, b))
if op != None:
tela.clear()
tela.onkey(GraficoSobreposicao(linhas_arq), "Up")
tela.listen()
else:
exit()
turtle.done()