def _items_to_fill_voids():
result = dict()
for date in Settings().dates:
result[date] = ''
return result
def _create_indicators(self):
result = dict()
for item in Settings().list_of_financial_performance_items.keys():
result[item] = self._items_to_fill_voids()
return result
def run(self):
self.ocr_areas = None
self.min_contrast = 0.0
self.max_contrast = 255.0
self.settings = Settings()
self.bestlist = []
self.image_data = []
for file in self.imglist:
#print file
image = cv2.imread(
unicode(file).encode(sys.getfilesystemencoding()))
h, w, c = image.shape
#if h > 1080:
# width = int(w*(900.0/h))
# image = cv2.resize(image, (width, 900))
self.calculate(image)
clean = {}
total = len(self.bestlist)
for i in xrange(int(self.min_contrast), int(self.max_contrast)):
count = 0
temp = 0
for item in self.bestlist:
if float(i) in item:
count += 1
temp += item[float(i)]
if count == total:
clean[i] = temp
#print clean
cleanlist = sorted(clean.items(), key=lambda x: x[1])
tolerance = cleanlist[0][1] + 2
tolerated = []
for j in range(len(cleanlist)):
if cleanlist[j][1] < tolerance:
tolerated.append(cleanlist[j][0])
#print tolerated
self.bestcontrast = reduce(lambda x, y: x + y,
tolerated) / len(tolerated)
self.error = cleanlist[0][1]
#print self.bestcontrast
"""
hist = []
for i in xrange(256):
if i in clean:
hist.append(clean[i])
else:
hist.append(0)
hist = np.asarray(hist)
cv2.normalize(hist,hist,0,1000,cv2.NORM_MINMAX)
h = np.zeros((1000,256,3))
for x in xrange(len(hist)):
cv2.line(h,(x,hist[x]),(x,hist[x]),(255,255,255))
y=np.flipud(h)
cv2.imshow('histogram',y)
cv2.waitKey(0)
"""
#self.emit(SIGNAL("update(int,int)"), counter, toprocess)
#self.result = "Success: "+unicode(len(outcomeok))+" Fail: "+unicode(len(outcomefail))
ct = ColorThief(image)
palette = ct.get_palette()
for i in xrange(1, 6):
self.settings.reg.setValue('color' + str(i),
QColor(*(palette[i - 1])).name())
self.emit(SIGNAL("finished(float, int, PyQt_PyObject)"),
self.bestcontrast, self.error, self.image_data)
def __init__(self):
#Задаём настрйоки игры
self.settings = Settings()
import cv2
from settings import Settings
import numpy as np
from functions import findtarget_method_2
parameters = Settings()
p = 0
cap = cv2.VideoCapture(0)
out = cv2.VideoWriter('output.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 8, (640,480))
while not cap.isOpened():
p = p + 1
print('camera is not opened ', p)
cap = cv2.VideoCapture(p)
cap.set(3, parameters.photo_width)
cap.set(4, parameters.photo_high)
cap.set(5,8)
while True:
ret, img = cap.read()
if ret == 1:
# h, w = img.shape[:2]
# newcameramtx, roi = cv2.getOptimalNewCameraMatrix(parameters.mtx, parameters.dist, (w, h), 0, (w, h))
# dst = cv2.undistort(img, parameters.mtx, parameters.dist, None, newcameramtx)
# GrayImage = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# MD = cv2.medianBlur(GrayImage, 5)
try:
x, y, R = findtarget_method_2(parameters, img)
cv2.circle(img,(x,y),R,(255,0,0),2)
print('find target')
except:
print('target is not found')
cv2.imshow('img',img)
out.write(img)
def run_game():
# нициализирует pygame, settings и объект экрана.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
background_image = pygame.image.load("background.jpg").convert()
background_image = pygame.transform.scale(
background_image,
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
clock = pygame.time.Clock()
fps = 90
# Создание кнопки Play.
play_button = Button(ai_settings, screen, "Play")
# Создание корабля, группы пуль и группы пришельцев.
ship = Ship(ai_settings, screen)
bullets = Group()
enemys = Group()
# Создание экземпляров GameStats и Scoreboard.
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Создание флота пришельцев.
gf.create_fleet(ai_settings, screen, ship, enemys)
def load_image(name):
fullname = 'images' + '/' + name
try:
if name[-2:] == 'jpg' or name[-2:] == 'png':
image = pygame.image.load(fullname).convert()
else:
image = pygame.image.load(fullname).convert_alpha()
except:
print('Cannot load image:', name)
raise SystemExit()
return image
class AnimateSprite(pygame.sprite.Sprite):
def __init__(self, image, columns, rows, x, y):
super().__init__()
self.frames = []
self.cut_image(image, columns, rows)
self.frame_number = 0
self.image = self.frames[self.frame_number]
self.rect = self.rect.move(x, y)
self.add(all_sprites)
def cut_image(self, image, columns, rows):
"""Разрезает картинку спрайта на равные части"""
self.rect = pygame.Rect(0, 0,
image.get_width() // columns,
image.get_height() // rows)
for j in range(rows):
for i in range(columns):
frame_location = (self.rect.w * i, self.rect.h * j)
self.frames.append(
image.subsurface(
pygame.Rect(frame_location, self.rect.size)))
def update(self):
self.frame_number = (self.frame_number + 1) % len(self.frames)
self.image = self.frames[self.frame_number]
all_sprites = pygame.sprite.Group()
deton = AnimateSprite(load_image("deton.png"), 8, 6, 400, 700)
# Запуск основного цикла игры.
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
enemys, bullets)
screen.blit(background_image, [0, 0])
all_sprites.draw(screen)
all_sprites.update()
clock.tick(fps)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, enemys,
bullets)
gf.update_enemys(ai_settings, screen, stats, sb, ship, enemys,
bullets)
gf.update_screen(ai_settings, screen, stats, sb, play_button, ship,
enemys, bullets)
# Отображение последнего прорисованного экрана.
pygame.display.flip()
def main(_run, _config, _log):
for source_file, _ in _run.experiment_info['sources']:
os.makedirs(os.path.dirname(f'{_run.observers[0].dir}/source/{source_file}'),
exist_ok=True)
_run.observers[0].save_file(source_file, f'source/{source_file}')
shutil.rmtree(f'{_run.observers[0].basedir}/_sources')
set_seed(_config['seed'])
cudnn.enabled = True
cudnn.benchmark = True
torch.cuda.set_device(device=_config['gpu_id'])
torch.set_num_threads(1)
settings = Settings()
common_params, data_params, net_params, train_params, eval_params = settings['COMMON'], settings['DATA'], settings[
'NETWORK'], settings['TRAINING'], settings['EVAL']
_log.info('###### Create model ######')
model = fs.FewShotSegmentorDoubleSDnet(net_params).cuda()
# model = nn.DataParallel(model.cuda(), device_ids=[_config['gpu_id'],])
if not _config['notrain']:
model.load_state_dict(torch.load(_config['snapshot'], map_location='cpu'))
model.eval()
_log.info('###### Load data ######')
data_name = _config['dataset']
make_data = meta_data
max_label = 1
tr_dataset, val_dataset, ts_dataset = make_data(_config)
testloader = DataLoader(
dataset=ts_dataset,
batch_size=1,
shuffle=False,
# num_workers=_config['n_work'],
pin_memory=False, # True
drop_last=False
)
if _config['record']:
_log.info('###### define tensorboard writer #####')
board_name = f'board/test_{_config["board"]}_{date()}'
writer = SummaryWriter(board_name)
_log.info('###### Testing begins ######')
# metric = Metric(max_label=max_label, n_runs=_config['n_runs'])
img_cnt = 0
# length = len(all_samples)
length = len(testloader)
img_lists = []
pred_lists = []
label_lists = []
saves = {}
for subj_idx in range(len(ts_dataset.get_cnts())):
saves[subj_idx] = []
with torch.no_grad():
loss_valid = 0
batch_i = 0 # use only 1 batch size for testing
for i, sample_test in enumerate(testloader): # even for upward, down for downward
subj_idx, idx = ts_dataset.get_test_subj_idx(i)
img_list = []
pred_list = []
label_list = []
preds = []
s_x = sample_test['s_x'].cuda() # [B, Support, slice_num=1, 1, 256, 256]
X = s_x.squeeze(2) # [B, Support, 1, 256, 256]
s_y = sample_test['s_y'].cuda() # [B, Support, slice_num, 1, 256, 256]
Y = s_y.squeeze(2) # [B, Support, 1, 256, 256]
Y = Y.squeeze(2) # [B, Support, 256, 256]
q_x = sample_test['q_x'].cuda() # [B, slice_num, 1, 256, 256]
query_input = q_x.squeeze(1) # [B, 1, 256, 256]
q_y = sample_test['q_y'].cuda() # [B, slice_num, 1, 256, 256]
y2 = q_y.squeeze(1) # [B, 1, 256, 256]
y2 = y2.squeeze(1) # [B, 256, 256]
y2 = y2.type(torch.LongTensor).cuda()
entire_weights = []
for shot_id in range(_config["n_shot"]):
input1 = X[:, shot_id, ...] # use 1 shot at first
y1 = Y[:, shot_id, ...] # use 1 shot at first
condition_input = torch.cat((input1, y1.unsqueeze(1)), dim=1)
weights = model.conditioner(condition_input) # 2, 10, [B, channel=1, w, h]
entire_weights.append(weights)
# pdb.set_trace()
avg_weights=[[],[None, None, None, None]]
for k in range(9):
weight_cat = torch.cat([weights[0][k] for weights in entire_weights],dim=1)
avg_weight = torch.mean(weight_cat,dim=1,keepdim=True)
avg_weights[0].append(avg_weight)
avg_weights[0].append(None)
output = model.segmentor(query_input, avg_weights)
q_yhat = output.argmax(dim=1)
q_yhat = q_yhat.unsqueeze(1)
preds.append(q_yhat)
img_list.append(q_x[batch_i,0].cpu().numpy())
pred_list.append(q_yhat[batch_i].cpu().numpy())
label_list.append(q_y[batch_i,0].cpu().numpy())
saves[subj_idx].append([subj_idx, idx, img_list, pred_list, label_list])
print(f"test, iter:{i}/{length} - {subj_idx}/{idx} \t\t", end='\r')
img_lists.append(img_list)
pred_lists.append(pred_list)
label_lists.append(label_list)
print("start computing dice similarities ... total ", len(saves))
dice_similarities = []
for subj_idx in range(len(saves)):
imgs, preds, labels = [], [], []
save_subj = saves[subj_idx]
for i in range(len(save_subj)):
# print(len(save_subj), len(save_subj)-q_slice_n+1, q_slice_n, i)
subj_idx, idx, img_list, pred_list, label_list = save_subj[i]
# print(subj_idx, idx, is_reverse, len(img_list))
# print(i, is_reverse, is_reverse_next, is_flip)
for j in range(len(img_list)):
imgs.append(img_list[j])
preds.append(pred_list[j])
labels.append(label_list[j])
# pdb.set_trace()
img_arr = np.concatenate(imgs, axis=0)
pred_arr = np.concatenate(preds, axis=0)
label_arr = np.concatenate(labels, axis=0)
# pdb.set_trace()
# print(ts_dataset.slice_cnts[subj_idx] , len(imgs))
# pdb.set_trace()
dice = np.sum([label_arr * pred_arr]) * 2.0 / (np.sum(pred_arr) + np.sum(label_arr))
dice_similarities.append(dice)
print(f"computing dice scores {subj_idx}/{10}", end='\n')
if _config['record']:
frames = []
for frame_id in range(0, len(save_subj)):
frames += overlay_color(torch.tensor(imgs[frame_id]), torch.tensor(preds[frame_id]).float(), torch.tensor(labels[frame_id]))
visual = make_grid(frames, normalize=True, nrow=5)
writer.add_image(f"test/{subj_idx}", visual, i)
writer.add_scalar(f'dice_score/{i}', dice)
print(f"test result \n n : {len(dice_similarities)}, mean dice score : \
{np.mean(dice_similarities)} \n dice similarities : {dice_similarities}")
if _config['record']:
writer.add_scalar(f'dice_score/mean', np.mean(dice_similarities))
def main():
## Import Settings
s = Settings()
# Import Landmarks
landmarks = l.choose_landmark_loop(s.display_width, s.display_height)
# Initiate Pygame Attrributes
win = pygame.display.set_mode((s.display_width, s.display_height))
pygame.display.set_caption("Particle Filter: Cat on Roomba")
clock = pygame.time.Clock()
image = pygame.image.load('resources/cat_roomba2.png')
# Set up main Avatar - Cat on Roomba
roomba = Particle(s.displacement, s.display_width, s.display_height)
# Creates Particles for the particle filter
particles = create_particles(s.num_particles, s.displacement,
s.forward_variance, s.turn_variance,
s.sensor_variance, s.display_width,
s.display_height)
# Draw initial game window, particles, and avatar
draw.game_window(255, win, landmarks, s.display_width, s.display_height)
draw.particle(particles, win)
draw.avatar(image, roomba.x, roomba.y, roomba.angle, win)
pygame.display.flip()
app_status = True
while app_status:
"""This is the main loop that runs the entire application"""
# This controls quitting the application
# For some reason it doesn't like getting put into
# another definition
for event in pygame.event.get():
if event.type == pygame.QUIT:
app_status = False
# Controls the speed and direction of avatar
turn = 0.0
keys = pygame.key.get_pressed()
s.displacement, turn = button_event(keys, turn, s.displacement)
roomba = roomba.move(turn, s.displacement, s.display_width,
s.display_height)
# Gets distances of landmarks from avatar
observations = roomba.sense(landmarks)
# Changes position of particles the same way the avatar moves
particles = move_particle(particles, turn, s.displacement,
s.display_width, s.display_height)
# Gets the weight of each particle
# Essentially a measure of how close to ideal it is
weights = get_weights(particles, observations, landmarks)
# Creates new generation of particles based on old one
# Best ones have higher probability of surviving
particles = resample_particles(particles, weights, s.num_particles)
# Calculate Error
error = mean_error(roomba, particles, s.display_width,
s.display_height)
#Draws updated Windows/Particles/Avatar
draw.game_window(error, win, landmarks, s.display_width,
s.display_height)
draw.particle(particles, win)
draw.avatar(image, roomba.x, roomba.y, roomba.angle, win)
pygame.display.flip()
# Reduces the speed of the loop so it doesn't use to much CPu
clock.tick(s.refresh_rate)
def save_model(E, W, version):
E = E.detach().cpu().numpy()
W = W.detach().cpu().numpy()
np.save('E_notrasfer_' + version + '.npy', E)
np.save('W_notransfer_' + version + '.npy', W)
print('max value in E: ', np.max(E))
print('max value in W: ', np.max(W))
print('sum of all values in E: ', E.sum())
print('sum of all in W: ', W.sum())
if __name__ == "__main__":
print('Now without dividing total loss by n_batches')
params = Settings() # get model parameters
args = parse_args()
params.set(args)
print('Embedding model - ' + args.word_model)
hp = Hyperparameters()
hp.set(args)
#set_params(params, args)
if args.sim_matrix == 'fromfile':
V = sparse.load_npz('V_' + args.dataset + '.npz')
print('Loaded TFIDF Matrix')
Sw = sparse.load_npz('Sw_' + args.dataset + '.npz')
print('Loaded Sw matrix')
Se = sparse.load_npz('Se_' + args.dataset + '.npz')
print('Loaded Se matrix')
def open_settings(self):
"""
Obri la finestra dels settings on es canviaràn els temps màxims i mínims del segments i total.
"""
self.new_window = Settings()
def play(self):
ai_settings = Settings()
screen = pg.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pg.display.set_caption(ai_settings.title)
play_button = Button(screen, "Play")
score_button = ScoreButton(ai_settings, screen, "High Score")
stats = GameStats(ai_settings=ai_settings)
sb = Scoreboard(ai_settings=ai_settings, screen=screen, stats=stats)
sound = Sound()
sound.play()
sound.pause_bg()
ship = Ship(ai_settings=ai_settings, screen=screen)
ships = Group()
ships.add(ship)
barriers = Group()
aliens = Group()
bullets = Group()
alien_bullets = Group()
aliens_list = []
timer = [pg.time.get_ticks()]
UFO_object = UFO(ai_settings=ai_settings, screen=screen)
UFOs = Group()
UFOs.add(UFO_object)
timer_score_display = [pg.time.get_ticks()]
for ship in ships:
gf.create_fleet(ai_settings=ai_settings,
screen=screen,
ship=ship,
aliens=aliens)
gf.create_barriers(ai_settings=ai_settings,
screen=screen,
barriers=barriers)
screen.fill(ai_settings.bg_color)
while True:
gf.check_events(ai_settings=ai_settings,
screen=screen,
play_button=play_button,
scores_button=score_button,
stats=stats,
sb=sb,
sound=sound,
ships=ships,
aliens=aliens,
bullets=bullets)
if stats.game_active:
gf.update_ships(ai_settings=ai_settings,
screen=screen,
stats=stats,
sb=sb,
sound=sound,
ships=ships,
aliens=aliens,
bullets=bullets,
alien_bullets=alien_bullets,
UFOs=UFOs)
gf.update_aliens(ai_settings=ai_settings,
screen=screen,
stats=stats,
sb=sb,
sound=sound,
ships=ships,
aliens=aliens,
bullets=bullets,
alien_bullets=alien_bullets,
timer=timer,
aliens_list=aliens_list,
UFOs=UFOs)
gf.update_bullets(ai_settings=ai_settings,
screen=screen,
stats=stats,
sb=sb,
sound=sound,
ships=ships,
aliens=aliens,
bullets=bullets,
barriers=barriers)
gf.update_alien_bullets(ai_settings=ai_settings,
ships=ships,
alien_bullets=alien_bullets,
barriers=barriers)
gf.update_UFO(ai_settings=ai_settings,
screen=screen,
stats=stats,
sb=sb,
sound=sound,
bullets=bullets,
UFOs=UFOs,
timer_value_display=timer_score_display)
else:
screen.blit(self.game_title, (300, 100))
screen.blit(self.alien_one, (200, 250))
screen.blit(self.alien_one_label, (235, 380))
screen.blit(self.alien_two, (400, 250))
screen.blit(self.alien_two_label, (435, 380))
screen.blit(self.alien_three, (600, 250))
screen.blit(self.alien_three_label, (635, 380))
screen.blit(self.ufo, (800, 220))
screen.blit(self.ufo_label, (852, 380))
gf.update_screen(ai_settings=ai_settings,
screen=screen,
play_button=play_button,
score_button=score_button,
stats=stats,
sb=sb,
sound=sound,
ships=ships,
aliens=aliens,
bullets=bullets,
alien_bullets=alien_bullets,
UFOs=UFOs,
timer_score_display=timer_score_display,
barriers=barriers)
def play():
handler = Stringhandler()
settings = Settings()
goal = settings.getGoal()
difficulty = settings.difficulty
player = Player()
item = Items()
intro = handler.strIntro()
for char in "\n"+intro+"\n":
time.sleep(uniform(0.05, 0.1))
sys.stdout.write('\033[35m'+'\033[1m'+char)
sys.stdout.flush()
name_input = raw_input (Fore.CYAN +'\n>: ')
player.name = name_input
#
# Asks for the player Name
#
print Style.BRIGHT + Fore.WHITE
greeting = handler.strGreeting(player)
string = re.sub(r'(\x1b[^m]*m)',"", str(greeting+"\n"))
pos = string.find(player.name)
for index, char in enumerate(string):
time.sleep(uniform(0.05, 0.1))
if index >= pos and index < pos+len(player.name):
sys.stdout.write('\033[36m'+char)
elif index == pos+len(player.name):
sys.stdout.write('\033[37m'+char)
else:
sys.stdout.write('\033[37m'+char)
sys.stdout.flush()
if not player.is_in_room:
player.addItem(item.newPotion(0.2,5))
room = Room(difficulty,player)
time.sleep(0.5)
chest = room.newRoom()
string = room.monster.spawn(room,player)
if room.hasMonster:
player.is_in_room = True
print str(string)
else:
print chest
#
# Game Loop start
#
while player.is_alive():
if player.victory:
print self.handler.strBasic("win")
end_input = raw_input(Fore.CYAN +"\n"+ player.name+ '>: ')
if end_input.lower() == "restart":
print handler.strBasic("restart")
play()
elif end_input.lower() == "exit":
print handler.strBasic("exit")
break;
else:
#print ("\nWhat do you want to do?\n")
action_input = raw_input(Fore.CYAN +"\n"+ player.name+ '>: ')
print Fore.WHITE
if room.is_done() and ("go" in action_input.lower() or "walk" in action_input.lower() or "continue" in action_input.lower()):
response = actions(action_input,player,room)
print response
room = room.getRoom(difficulty,player)
chest = room.newRoom()
string = room.monster.spawn(room,player)
if room.hasMonster:
print str(string)
else:
print chest
elif action_input.lower() == "restart":
player.alive = True
print handler.strBasic("restart")
play()
elif action_input.lower() == "exit":
print handler.strBasic("exit")
break;
else:
# The magic happens here:
time.sleep(0.5)
print actions(action_input,player,room)
if player.victory:
print "Victory!"
def parse(self, response):
global ult
datas = response.selector.xpath(
'//tr/td[@class="date"]/text()').extract()
links = response.selector.xpath('//tr/td[5]/a/@href').extract()
descs = response.selector.xpath('//tr/td[5]/a[@href]/text()').extract()
for data, desc, link in zip(datas, descs, links):
if desc.encode('utf-8') != ult and ult == '':
with open('baseWebApp.txt', 'a+') as arq:
arq.write(data.strip() + '\n')
arq.write(desc.encode('utf-8') + '\n')
arq.write(link + '\n\n')
arq.close()
i = 0
elif desc.encode('utf-8') != ult:
with open('aux.txt', 'a+') as arq:
arq.write(data.strip() + '\n')
arq.write(desc.encode('utf-8') + '\n')
arq.write(link + '\n\n')
arq.close()
i = 1
else:
i = 0
break
if not i:
if os.path.exists('aux.txt'):
os.remove('baseWebApp.txt')
os.rename('aux.txt', 'baseWebApp.txt')
access_token = Settings().facebook_access_token
api = facebook.GraphAPI(access_token)
total = 0
arq = open('baseWebApp.txt', 'r')
linhas = arq.readlines()
for i in linhas:
if i == '\n':
total = total + 1
a = 0
b = 3
lista = []
for i in range(total):
xxx = linhas[a:b]
lista.append(xxx)
xxx = ''
a = b + 1
b = a + 3
lista.reverse()
for i in lista:
x = ''.join(i)
api.put_wall_post(x)
raise CloseSpider('[+] BASE ATUALIZADA [+]')
else:
try:
proxima_pagina = response.xpath(
'//a[@href and contains(.,"next")]/@href').extract()[0]
if proxima_pagina:
yield scrapy.Request(url=proxima_pagina,
callback=self.parse)
except:
pass
def resetar(self):
pygame.init()
self.sons = Sons()
self.ai_settings = Settings()
self.screen = pygame.display.set_mode(
(self.ai_settings.screen_width, self.ai_settings.screen_height))
# ponteiro do mause disaparece
pygame.mouse.set_visible(True)
# Cria espaçonave
self.painel_vacina = Painel_vacina(self.ai_settings, self.screen)
self.mira = Mira(self.ai_settings, self.screen, self.painel_vacina)
# Grupo de virus
self.viroses = Group()
self.miras = Group()
self.mira_colisor = Mira_colisor(self.ai_settings, self.screen)
self.miras.add(self.mira_colisor)
pygame.display.set_caption('VAC')
# Define background
self.background = pygame.image.load(self.ai_settings.background_path)
self.background = pygame.transform.scale(
self.background, (self.ai_settings.screen_width + 500,
self.ai_settings.screen_height))
self.background_init = pygame.image.load(
self.ai_settings.background_path_init)
self.background_init = pygame.transform.scale(
self.background_init,
(self.ai_settings.screen_width, self.ai_settings.screen_height))
""" Define o estado do jogo"""
self.barra_tempo = Barra_tempo(self.ai_settings, self.screen)
# Define um multiprocess
self.atualiza_movimento = UpMovVirus(self.viroses)
self.estado_jogo = EstadoJogo(self.ai_settings, self.viroses,
self.screen, self.painel_vacina,
self.barra_tempo,
self.atualiza_movimento)
self.barra_tempo.estado_jogo = self.estado_jogo
if self.estado_jogo.fullscreen:
self.screen = pygame.display.set_mode(
(self.ai_settings.screen_width,
self.ai_settings.screen_height), pygame.FULLSCREEN)
self.pontuacao_placar = Pontuacao(self.ai_settings, self.screen,
self.estado_jogo)
self.pontuacao_placar.inicia_pontos()
self.estado_jogo.pontuacao = self.pontuacao_placar
grupos_viroses = gf.coloca_virus_tela(self.ai_settings, self.screen,
self.viroses, self.estado_jogo)
self.estado_jogo.set_grupo_viroses(grupos_viroses)
""" Indica estado do jogo se está iniciado ou não"""
# Define um multiprocess
self.atualiza_barra_tempo = UpMovBarra(self.barra_tempo,
grupos_viroses)
self.ranking_bd = Ranking('bd_score', self.nome_player)
self.play_botao = Botao(self.ai_settings, self.screen,
'./imagens/icones/iniciar.png',
self.func_call_back_play)
self.ranking_botao = Botao(self.ai_settings, self.screen,
'./imagens/icones/ranking.png',
self.func_call_back_ranking)
self.play_botao.rect.centerx = 350
self.play_botao.rect.bottomleft = (
self.screen.get_rect().bottomleft[0] + 50,
self.screen.get_rect().bottomleft[1] - 50)
self.ranking_botao.rect.bottomright = (
self.screen.get_rect().bottomright[0] - 50,
self.screen.get_rect().bottomright[1] - 50)
self.pause_botao = Botao(self.ai_settings, self.screen,
'./imagens/icones/pause-play.png',
self.func_call_back_pause)
self.pause_botao.altura = 50
self.pause_botao.largura = 50
self.pause_botao.make_rect()
self.pause_botao.rect.centerx = self.ai_settings.screen_width - 30
self.pause_botao.rect.centery = 70
self.vetor_botoes = []
self.vetor_botoes.append(self.play_botao)
self.vetor_botoes.append(self.ranking_botao)
self.vetor_botoes.append(self.pause_botao)
pygame.mixer.music.play(-1)
def __init__(self):
settings = Settings()
self.client = MongoClient(settings.mongo)
self.db = self.client.process_database
self.rect.y -= self.vely
mouse_x = pygame.mouse.get_pos()[0]
print(mouse_x)
self.new_pos = [self.rect.x, self.rect.y]
self.rect = self.new_pos
self.rect.y += self.vely
print("it fired (not really yet)")
def blitme(self):
screen.blit(self.image, self.new_pos)
# # print(self.pos)
print("draw cannon is calling")
# global variables
game_settings = Settings()
screen = pygame.display.set_mode(
(game_settings.screen_width, game_settings.screen_height))
cannon = Cannon_ball(screen, game_settings)
flower = Flower(game_settings, screen)
bomb = bobOmb(game_settings, screen)
cloud = Cloud(game_settings, screen)
all_sprites = pygame.sprite.Group()
bombs = pygame.sprite.Group()
#function that takes a new entity from the sprite group
def runGame():
#initialize pygame, settings, and screen object
#initialize
pygame.init()
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Bun Blaster")
#create and instance to store game stats and create scoreboard
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.buns = pygame.sprite.Group()
self.stars = pygame.sprite.Group()
self._create_batch()
self._create_star_sky()
#make the the Play button
self.play_button = Button(self)
self.play_button._prep_msg("Play")
# get the screen dimensions to be used to place buttons
self.screen_rect = self.screen.get_rect()
#make the easy button
self.easy_button = Button(self)
self.easy_button.button_color = (0, 0, 255) #blue
self.easy_button.rect.centerx = (self.screen_rect.centerx -
self.easy_button.width - 50)
self.easy_button._prep_msg("Easy")
#make the normal button
self.normal_button = Button(self)
self.normal_button.button_color = (0, 255, 0) #green
self.normal_button.rect.center = self.screen_rect.center
self.normal_button._prep_msg("Normal")
#make the hard button
self.hard_button = Button(self)
self.hard_button.button_color = (255, 0, 0) #red
self.hard_button.rect.centerx = (self.screen_rect.centerx +
self.hard_button.width + 50)
self.hard_button._prep_msg("Hard")
#make the title
self.title_box = Button(self)
self.title_box.width = 700
self.title_box.button_color = (0, 0, 0) #red
self.title_box.rect.centery = (self.screen_rect.centery -
self.title_box.height - 25)
self.title_box.font = pygame.font.SysFont(None, 36)
self.title_box._prep_msg("Click to choose a difficulty level:")
#initialize sound effects
self.explode = pygame.mixer.Sound('sounds/explosion_medium.wav')
self.fire = pygame.mixer.Sound(
'sounds/leisure_video_game_retro_laser_gun_fire_004.wav')
self.click = pygame.mixer.Sound('sounds/button_click.wav')
self.level_up = pygame.mixer.Sound('sounds/level_up.wav')
self.crash = pygame.mixer.Sound('sounds/crash.wav')
self.end = pygame.mixer.Sound('sounds/fail_theme.wav')
def center_ship(self):
"""Center the ship on the screen"""
self.center = self.screen_rect.centerx
def imagerect(self):
return Ship.timer.imagerect()
def explode(self):
self.screen.blit(self.explosion_timer.imagerect(), self.rect)
pygame.display.flip()
if __name__ == '__main__':
pygame.init()
settings = Settings()
screen = pygame.display.set_mode((settings.screen_width,
settings.screen_height))
clock = pygame.time.Clock()
ship = Ship(settings, screen)
explode = False
while True:
screen.fill((0, 0, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.type == pygame.K_SPACE:
explode = True
class ADS1299(object):
DEFAULT_SETTINGS = Settings()
DEFAULT_SETTINGS.update({
# === SPI Settings ===
# 2.25MHz >= f(spi) >= 1.5MHz in spec.
"SPI_FREQUENCY": int(2.25 * 10**6),
"SPI_CHANNEL": 5, # SPI channel in EEG block 1.2 is 5.
"SPI_MODE": mraa.SPI_MODE1, # SPI mode 1 in spec
# === HARDWARE Settings ===
"PIN_POWER": 46,
"PIN_RESET": 32,
"PIN_START": 45,
"PIN_READY": 31,
"PIN_CHIP_SELECT": 23,
"PIN_CHIP_SELECT_2": 47,
})
@staticmethod
def init_gpio(pin, dir, mode):
# Set direction and pull-down/pull-up for an mraa gpio pin,
# and return mraa.Gpio object.
gpio = mraa.Gpio(pin)
gpio.dir(dir)
gpio.mode(mode)
return gpio
def __init__(self):
# Initialize an ADS1299 object
self.SETTINGS = Settings()
self.SETTINGS.update(ADS1299.DEFAULT_SETTINGS)
try:
# Lazy import local settings when __init__ is called.
# If local settings exist, overwrite this object settings.
from .settings import LOCAL_SETTINGS
self.SETTINGS.update(LOCAL_SETTINGS)
except ImportError:
pass
# Initialize SPI for ADS1299
self.spi = mraa.Spi(self.SETTINGS.SPI_CHANNEL)
self.spi.frequency(self.SETTINGS.SPI_FREQUENCY)
self.spi.mode(self.SETTINGS.SPI_MODE)
# Initialize hardware control for ADS1299
self.hardware = Hardware()
self.hardware.power = self.init_gpio(self.SETTINGS.PIN_POWER,
mraa.DIR_OUT_LOW,
mraa.MODE_STRONG)
self.hardware.reset = self.init_gpio(self.SETTINGS.PIN_RESET,
mraa.DIR_OUT_HIGH,
mraa.MODE_STRONG)
self.hardware.start = self.init_gpio(self.SETTINGS.PIN_START,
mraa.DIR_OUT_LOW,
mraa.MODE_STRONG)
self.hardware.ready = self.init_gpio(self.SETTINGS.PIN_READY,
mraa.DIR_IN, mraa.MODE_HIZ)
self.hardware.chip_select = self.init_gpio(
self.SETTINGS.PIN_CHIP_SELECT, mraa.DIR_OUT_HIGH, mraa.MODE_STRONG)
self.hardware.chip_select_2 = self.init_gpio(
self.SETTINGS.PIN_CHIP_SELECT_2, mraa.DIR_OUT_HIGH,
mraa.MODE_STRONG)
self.hardware.power.write(1) # power up
# wait for internal reference waking up (150ms)
# wait for internal clock waking up (20us)
# wait for external cloxk waking up (1.5ms)
sleep(160 * 10**(-3))
self.hardware.reset.write(0) # reset ADS1299
sleep(1 * 10**(-3)) # wait for reset register (18 CLK)
self.hardware.reset.write(1) # finish reseting ADS1299
# Connect Register controller for ADS1299
self.register = Register(self.spi, self.hardware.chip_select)
@staticmethod
def parse_data(data):
# parse data
message = "Good," if (data[0] & 0xC00000 == 0xC00000) else "Bad, "
loffp = "".join(
["T" if (data[0] & (1 << i)) else "F" for i in range(19, 11, -1)])
loffn = "".join(
["T" if (data[0] & (1 << i)) else "F" for i in range(11, 3, -1)])
gpio = "".join(
["I" if (data[0] & (1 << i)) else "O" for i in range(3, -1, -1)])
channel = ",".join([
str(data[_] - 2 * (data[_] & 0x800000)).rjust(10, ' ')
for _ in range(1, 9)
])
message += "LOFF,(P):" + loffp + ",(N):" + loffn + ",GPIO:" + gpio + ",Data:" + channel
return message
def write_command(self, command):
self.hardware.chip_select.write(0)
self.spi.writeByte(command)
self.hardware.chip_select.write(1)
self.hardware.chip_select_2.write(0)
self.spi.writeByte(command)
self.hardware.chip_select_2.write(1)
def wakeup(self):
self.write_command(0x02)
def standby(self):
self.write_command(0x04)
def reset(self):
self.write_command(0x06)
def start(self):
self.write_command(0x08)
def stop(self):
self.write_command(0x0A)
def rdatac(self):
self.write_command(0x10)
def sdatac(self):
self.write_command(0x11)
def rdata(self, init=False):
# read data
if init:
self.start()
self.sdatac()
while self.hardware.ready.read() != 0:
pass
# (RDATA + STATUS(3) + 8Channel*3Byte)
command = bytearray(1 + 3 + 8 * 3)
command[0] = 0x12 # RDATA
self.hardware.chip_select.write(0)
result = self.spi.write(command)[1:]
self.hardware.chip_select.write(1)
print ADS1299.parse_data([(result[_ * 3] << 16) +
(result[_ * 3 + 1] << 8) + result[_ * 3 + 2]
for _ in range(9)])
def reg_map(self):
self.sdatac()
command = bytearray(2 + 0x18)
command[0] = 0x20 # Read REG @ address 0x00
command[1] = 0x17 # Read REG @ 0x18 registers
self.hardware.chip_select.write(0)
result = self.spi.write(command)[2:]
self.hardware.chip_select.write(1)
for _ in range(0x18):
print("0x" + hex(_)[2:].zfill(2)), ":", (
"0x" + hex(result[_])[2:].zfill(2)), bin(
result[_])[2:].zfill(8)
command = bytearray(2 + 0x18)
command[0] = 0x20 # Read REG @ address 0x00
command[1] = 0x17 # Read REG @ 0x18 registers
self.hardware.chip_select_2.write(0)
result = self.spi.write(command)[2:]
self.hardware.chip_select_2.write(1)
for _ in range(0x18):
print("0x" + hex(_)[2:].zfill(2)), ":", (
"0x" + hex(result[_])[2:].zfill(2)), bin(
result[_])[2:].zfill(8)
def overwirte_reg(self, value):
command = bytearray(2) + value
command[0] = 0x40 # Write REG @ address 0x00
command[1] = 0x17 # Write REG @ 0x18 registers
self.hardware.chip_select.write(0)
self.spi.write(command)
self.hardware.chip_select.write(1)
command = bytearray(2) + value
command[0] = 0x40 # Write REG @ address 0x00
command[1] = 0x17 # Write REG @ 0x18 registers
self.hardware.chip_select_2.write(0)
self.spi.write(command)
self.hardware.chip_select_2.write(1)
def log(self, sample):
file = open("EEG_log" + str(int(time())) + ".txt", 'w')
file2 = open("EEG2_log" + str(int(time())) + ".txt", 'w')
self.start()
self.sdatac()
command = bytearray(1 + 3 + 8 * 3)
command[0] = 0x12 # RDATA
while self.hardware.ready.read() != 0:
pass
for _ in range(sample):
while self.hardware.ready.read() != 0:
pass
#1
self.hardware.chip_select.write(0)
result = self.spi.write(command)[4:]
result = [(result[_ * 3] << 16) + (result[_ * 3 + 1] << 8) +
result[_ * 3 + 2] for _ in range(8)]
file.write(
str(time()).ljust(15, ' ') + "".join([
str(result[_] - 2 * (result[_] & 0x800000)).rjust(10, ' ')
for _ in range(8)
]) + "\n")
self.hardware.chip_select.write(1)
#2
self.hardware.chip_select_2.write(0)
result = self.spi.write(command)[4:]
result = [(result[_ * 3] << 16) + (result[_ * 3 + 1] << 8) +
result[_ * 3 + 2] for _ in range(8)]
file2.write(
str(time()).ljust(15, ' ') + "".join([
str(result[_] - 2 * (result[_] & 0x800000)).rjust(10, ' ')
for _ in range(8)
]) + "\n")
self.hardware.chip_select_2.write(1)
def upload(self):
broker_ip = '140.113.216.21'
broker_port = '1883'
topic = 'eeg/4/128'
self.start()
self.sdatac()
self.hardware.chip_select.write(0)
# (RDATA + STATUS(3) + 8Channel*3Byte)
command = bytearray(1 + 3 + 8 * 3)
command[0] = 0x12 # RDATA
try:
while True:
msg = ""
for i in range(32):
while self.hardware.ready.read() != 0:
pass
result = self.spi.write(command)[1:]
result = [
str((result[_ * 3] << 16) + (result[_ * 3 + 1] << 8) +
result[_ * 3 + 2]) for _ in range(1, 9)
]
msg += str(time()) + "," + ",".join(result) + ";"
#publish.single(topic, msg, hostname=broker_ip, port=broker_port)
except KeyboardInterrupt:
self.hardware.chip_select.write(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--mode',
'-m',
required=True,
help='run mode, valid values are train and eval')
parser.add_argument('--setting_path',
'-sp',
required=False,
help='optional path to settings_eval.ini')
args = parser.parse_args()
settings = Settings('settings.ini')
common_params, data_params, net_params, train_params, eval_params = settings['COMMON'], settings['DATA'], \
settings[
'NETWORK'], settings['TRAINING'], \
settings['EVAL']
if args.mode == 'train':
train(train_params, common_params, data_params, net_params)
elif args.mode == 'eval':
evaluate(eval_params, net_params, data_params, common_params,
train_params)
elif args.mode == 'eval_bulk':
logging.basicConfig(filename='error.log')
if args.setting_path is not None:
settings_eval = Settings(args.setting_path)
else:
settings_eval = Settings('settings_eval.ini')
def _menu_asset_pairs_change(self, widget):
if widget.get_active():
self.active_asset_pair = widget.get_name()
self.settings = Settings(self.active_exchange + ':' + self.active_asset_pair + ':' + str(self.refresh_frequency))
self._start_exchange()
