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()