def detect_natural_sign(self, natural_sign_dir: str) -> None: natural_sign_imgs = load_imgs(natural_sign_dir) detector = Detector(self, natural_sign_imgs, self._threshold_natural_sign) self._natural_sign_boxes = detector.detect() draw_boxes('natural_sign_boxes_img.png', self._img_rgb, self._natural_sign_boxes)
def detect_quarter_note(self, quarter_note_dir: str) -> None: quarter_note_imgs = load_imgs(quarter_note_dir) detector = Detector(self, quarter_note_imgs, self._threshold_quarter_note) self._quarter_note_boxes = detector.detect() draw_boxes('quarter_note_boxes_img.png', self._img_rgb, self._quarter_note_boxes)
def train_generator(img_paths, batch_size, model, y_true_sty, shuffle=True, epochs=None): n_samples = len(img_paths) indices = list(range(n_samples)) steps_per_epoch = math.ceil(n_samples / batch_size) img_paths = np.array(img_paths) cnt_epoch = 0 while True: cnt_epoch += 1 if shuffle: np.random.shuffle(indices) for i in range(steps_per_epoch): start = batch_size * i end = batch_size * (i + 1) X = load_imgs(img_paths[indices[start:end]], input_size) batch_size_act = X.shape[0] y_true_sty_t = [ np.repeat(feat, batch_size_act, axis=0) for feat in y_true_sty ] # exrtract content y_true_con = model.predict(X) yield (X, y_true_sty_t + [y_true_con]) if epochs is not None: if cnt_epoch >= epochs: raise StopIteration
def __init__(self, x, y, windowWidth, strength): img_lists = { "Ridle": ["boss_idle_1", "boss_idle_2"], "Odmg": ["boss_dmg"], "Oaa1": ["boss_atkranged1_1", "boss_atkranged1_2"], "Oaa2": ["boss_atkranged2_1", "boss_atkranged2_2"], "Oaa3": ["boss_atkranged3_1", "boss_atkranged3_2"], "D": ["boss_dead", "boss_dead"], } imgpath = "Images/Boss" imagesDemon = load_imgs(img_lists, imgpath, scale=4) atkList = [ Atk( "feu", 1.5, 32, 16, load_imgs({"idle": ["fire_1", "fire_2"]}, imgpath), 10, 3, -1, 0, 6, 0, 3000 ), Atk( "vent", 2, 32, 16, load_imgs({"idle": ["wind_1", "wind_1"]}, imgpath), 5, 6, -8, 0, 10, 0, 3000 ), Atk( "glace", 2, 32, 16, load_imgs({"idle": ["wind_1", "wind_1"]}, imgpath), 18, 2, 5, 0.8, 0, 0, 2000 ) ] Mob.__init__(self, x, y, 256, 96, imagesDemon, 0.01, 0.008, 2, 3, windowWidth, 250*strength, atkList) self.states["Oaa1Right"] = 200 self.states["Oaa1Left"] = 200 self.states["Oaa2Right"] = 200 self.states["Oaa2Left"] = 200 self.states["Oaa3Right"] = 200 self.states["Oaa3Left"] = 200 self.states["DRight"] = 200 self.states["DLeft"] = 200 self.strength = strength self.spellMax = int(7*strength) self.spellCount = 0 self.flee_x = 0 self.flee_y = 0 self.min_x = 5.0*windowWidth/10.0 self.max_x = windowWidth-self.rect.width self.max_y = y + 50 self.min_y = y self.flee_x = (pygame.time.get_ticks()%(self.max_x-self.min_x))+self.min_x self.flee_y = (pygame.time.get_ticks()%(self.max_y-self.min_y))+self.min_y self.flee_set = True
def detect_staff(self, staff_dir: str) -> None: staff_imgs = load_imgs(staff_dir) detector = Detector(self, staff_imgs, self._threshold_staff, is_staff=True) self._staff_boxes = detector.detect() self._staff_boxes.sort(key=lambda box: box.y) draw_boxes('staff_boxes_img.png', self._img_rgb, self._staff_boxes)
def __init__(self, x, y, windowWidth, strength): img_lists = { "Ridle": ["c_fly_1", "c_fly_2"], "Rmove": ["c_fly_1", "c_fly_2"], "Odmg": ["c_dmg"] } imgpath = "Images/Corbeau" imagesCorbeau = load_imgs(img_lists, imgpath) atkList = [ Atk("shuriken", 2, 16, 16, load_imgs({"idle": ["shuriken"]}, imgpath), 2, 3, 1, 0.3, 0, 2, 2000) ] Mob.__init__(self, x, y, 32, 32, imagesCorbeau, 0.01, 1, 1, 8, windowWidth, 10 * strength, atkList) self.strength = strength self.min_y = (pygame.time.get_ticks() % 100) + 300 self.left = True self.right = False
def __init__(self, x, y, windowWidth, strength): img_lists = { "Ridle": ["a_idle"], "Odmg": ["a_dmg_2"], "Oaa1": ["a_atk_1", "a_atk_2", "a_atk_3", "a_atk_4"], "Rmove": ["a_move_1", "a_move_2", "a_move_3"], } imgpath = "Images/Archer" imagesArcher = load_imgs(img_lists, imgpath) atkList = [ Atk("fleche", 3, 32, 16, load_imgs({"idle": ["Fleche"]}, imgpath), 2, 3, -1, 0.05, 15, -1, 3000) ] Mob.__init__(self, x, y, 64, 64, imagesArcher, 0.2, 1, 5, 7, windowWidth, 20 * strength, atkList) self.strength = strength self.arrowMax = 3 + int(strength) self.arrowCount = 0 self.flee_x = 0 self.flee_set = False
def __init__(self, x, y, windowWidth, strength): img_lists = { "Ridle": ["s_idle_1", "s_idle_2"], "Rmove": ["s_move_0", "s_move_1", "s_move_0", "s_move_1"], "Oaa1": ["s_atk_1", "s_atk_2", "s_atk_3", "s_atk_3"], "Odmg": ["s_dmg_2"], } imgpath = "Images/Samurai" imagesSamurai = load_imgs(img_lists, imgpath) atkList = [ Atk("sabre", 4, 96, 96, load_imgs({"idle": ["particle_sam"]}, imgpath), 10, 10, -4, 0, 4, 0, 400) ] Mob.__init__(self, x, y, 96, 96, imagesSamurai, 0.5, 1, 4, 3, windowWidth, 40 * strength, atkList) self.states["Oaa1Right"] = 100 self.states["Oaa1Left"] = 100 self.strength = strength self.areaWidth = 200
def __init__(self, x, y, windowWidth, strength): img_lists = { "Ridle": ["n_idle_1", "n_idle_2"], "Rmove": ["n_aa_1", "n_mv", "n_aa_1", "n_mv"], "Fjump": ["n_jp"], "Oaa1": ["n_aa_1", "n_aa_2", "n_aa_3", "n_aa_4"], "Odmg": ["n_hurt"], } imgpath = "Images/Ninja" imagesNinja = load_imgs(img_lists, imgpath) atkList = [ Atk("sabre", 2.5, 64, 32, load_imgs({"idle": ["particlehit"]}, "Images/Blanchon", 1), 10, 10, -1, 0, 0, 0, 400) ] Mob.__init__(self, x, y, 64, 64, imagesNinja, 0.3, 2, 8, 8, windowWidth, 30 * strength, atkList) self.strength = strength self.areaWidth = 250 self.left = False self.right = False
def run(): pygame.init() screen = pygame.display.set_mode((1280, 720), 0, 32) statesBlanchon = { "RidleRight": 500, "RidleLeft": 500, "RmoveLeft": 100, "RmoveRight": 100, "Oaa1Right": 75, "Oaa1Left": 75, "FcrouchLeft": 150, "FcrouchRight": 150 } imagesBlanchonList = { "Ridle": ["b_idle_1", "b_idle_2"], "Rmove": ["b_move_0", "b_move_1", "b_move_2", "b_move_1"], "Ffall": ["b_jumpdown_1", "b_jumpdown_2"], "Fcrouch": ["b_crouch_1", "b_crouch_2"], "Rslide": ["b_slide"], "Fjump": ["b_jumpup_1", "b_jumpup_2", "b_jumpup_3"], "Oaa1": ["b_aa1_1", "b_aa1_2", "b_aa1_3", "b_aa1_3"], "Oaa2": ["b_aa2_1", "b_aa2_2", "b_aa2_3", "b_aa2_4", "b_aa2_5", "b_aa2_5"], "Oaa3": [ "b_aa3_1", "b_aa3_2", "b_aa3_3", "b_aa3_4", "b_aa3_5", "b_aa3_6", "b_aa3_6", "b_aa3_6" ], "Oaaa": ["b_aa2_2", "b_atkjumpdown", "b_atkjumpdown"], "Odmg": ["b_dmg_2", "b_dmg_2"], "D": ["b_gameover", "b_gameover"], } path = "Images/Blanchon" imagesBlanchon = load_imgs(imagesBlanchonList, path, scale=8) blanchon = AnimItem(imagesBlanchon, statesBlanchon, 500, 384) anim = [blanchon] jouer = ["Jouer"] title = TitleItem("title", 500, 25) input_name = NameMenu(screen, jouer) credit_menu = CreditMenu(screen) leaderboard_menu = LeaderboardMenu(screen) menu = [input_name, credit_menu, leaderboard_menu] menu_items = ("DifNorm", "DifHard", "Tutoriel", "HighScores", "Credits", "Quitter") pygame.display.set_caption('Menu') gm = GameMenu(screen, menu_items, menu, title, anim) gm.run()
def eval_and_save_result(dataset_dir, model_path, eval_result_dirpath, eval_summary_name='eval_summary.yml', files_2b_copied=None, num_filters=64,num_maxpool=4, modulo=16): ''' ''' #---- load ---- train_dir = os.path.join(dataset_dir,'train') valid_dir = os.path.join(dataset_dir,'valid') test_dir = os.path.join(dataset_dir,'test') train_img_dir = os.path.join(train_dir,'image') train_label_dir = os.path.join(train_dir,'label') valid_img_dir = os.path.join(valid_dir,'image') valid_label_dir = os.path.join(valid_dir,'label') test_img_dir = os.path.join(test_dir, 'image') test_label_dir = os.path.join(test_dir, 'label') assert_exists(train_img_dir) assert_exists(train_label_dir) assert_exists(valid_img_dir) assert_exists(valid_label_dir) assert_exists(test_img_dir) assert_exists(test_label_dir) train_inputs = list(load_imgs(train_img_dir)) train_answers = list(load_imgs(train_label_dir)) valid_inputs = list(load_imgs(valid_img_dir)) valid_answers = list(load_imgs(valid_label_dir)) test_inputs = list(load_imgs(test_img_dir)) test_answers = list(load_imgs(test_label_dir)) #---- eval ---- segnet = model.unet(model_path, (None,None,1), num_filters=num_filters, num_maxpool=num_maxpool) train_iou_arr, train_result_tuples = evaluate(segnet, train_inputs, train_answers, modulo) valid_iou_arr, valid_result_tuples = evaluate(segnet, valid_inputs, valid_answers, modulo) test_iou_arr, test_result_tuples = evaluate(segnet, test_inputs, test_answers, modulo) K.clear_session() print('Evaluation completed!') #---- save ---- summary_path, train_path, valid_path, test_path = make_eval_directory(eval_result_dirpath, eval_summary_name) save_eval_summary(summary_path, train_iou_arr, valid_iou_arr, test_iou_arr) print('Evaluation summary is saved!') save_img_tuples(train_result_tuples, train_path) save_img_tuples(valid_result_tuples, valid_path) save_img_tuples(test_result_tuples, test_path) print('Evaluation result images are saved!') if files_2b_copied is None: files_2b_copied = [model_path] else: files_2b_copied.append(model_path) for file_path in files_2b_copied: file_name = os.path.basename(file_path) shutil.copyfile(file_path, os.path.join(eval_result_dirpath, file_name)) print("file '%s' is copyed into '%s'" % (file_name,eval_result_dirpath))
def __init__(self, x, y, windowWidth, strength): img_lists = { "Ridle": ["m_idle_1", "m_idle_2"], "Odmg": ["m_dmg"], "Oaa1": ["m_atk1_1", "m_atk1_2"], "Oaa2": ["m_atk2_1", "m_atk2_2"], "Oaa3": ["m_atk3_3", "m_atk3_2", "m_atk3_3", "m_atk3_4"], "D": ["m_dead_1", "m_dead_2"], } imgpath = "Images/Moine" imagesMoine = load_imgs(img_lists, imgpath) atkList = [ Atk( "violet", 2.5, 32, 16, load_imgs({"idle": ["m_atkranged1_1", "m_atkranged1_2"]}, imgpath), 7, -12, -5, 0, 6, 0, 3000), Atk( "lazer", 3, 32, 16, load_imgs({"idle": ["m_atkranged2_1", "m_atkranged2_2"]}, imgpath), 4, 3, -1, 0, 12, 0, 3000), Atk( "orbe", 0.1, 32, 32, load_imgs({"idle": ["m_atkranged3_1", "m_atkranged3_2"]}, imgpath), 10, 3, -3, 0.1, 2, -3, 4000) ] Mob.__init__(self, x, y, 64, 64, imagesMoine, 0.2, 0.5, 2, 4, windowWidth, 130 * strength, atkList) self.states["Oaa1Right"] = 200 self.states["Oaa1Left"] = 200 self.states["Oaa2Right"] = 200 self.states["Oaa2Left"] = 200 self.states["Oaa3Right"] = 150 self.states["Oaa3Left"] = 150 self.states["DRight"] = 200 self.states["DLeft"] = 200 self.areaWidth = 350 self.stockOrb = 4 self.strength = strength
logger_file = open(logger_path, 'w') print('epoch,loss_D,loss_G', file=logger_file) ''' imgs1 = load_imgs(img_dir1) idx, tags1 = load_anime_tags(tag_file1) imgs2 = load_imgs(img_dir2) tags2 = load_extra_tags(tag_file2) imgs = np.concatenate((imgs1[idx], imgs2), axis=0) tags = np.concatenate((tags1, tags2), axis=0) del imgs1, imgs2, tags1, tags2, idx ''' ### only extra data ### imgs = load_imgs(img_dir2) tags = load_extra_tags(tag_file2) ''' ### for img flip ### flip_imgs = np.array([ np.fliplr(img) for img in imgs ]) imgs = np.concatenate((imgs, flip_imgs), axis=0) tags = np.tile(tags, (2, 1)) ''' imgs = torch.FloatTensor(imgs).permute(0, 3, 1, 2) conds = torch.zeros((imgs.size(0), num_hair + num_eyes)) for i, tag in enumerate(tags): conds[(i, i), (hair_dict[tag[0]], eyes_dict[tag[1]] + num_hair)] = 1. dataset = TensorDataset(imgs, conds)
def main(self, name, difHard): from Model.class_Menu import DieMenu if name == "": name = "nom par defaut" pygame.init() WIDTH = 1280 HEIGHT = 720 fenetre = pygame.display.set_mode((WIDTH, HEIGHT), pygame.RESIZABLE) fond_e = pygame.transform.scale( pygame.image.load( "Images/Background/niveauRecurciforce.png").convert(), (WIDTH, HEIGHT)) blanchonAa1 = pygame.image.load("Images/Spell/aa1.png").convert() blanchonAa2 = pygame.image.load("Images/Spell/aa2.png").convert() blanchonAa3 = pygame.image.load("Images/Spell/aa3.png").convert() blanchonAaMidAir = pygame.image.load("Images/Spell/aaMidAir.png").convert() blanchonVector = pygame.image.load("Images/Spell/vector.png").convert() imagesBlanchonList = { "Ridle": ["b_idle_1", "b_idle_2"], "Rmove": ["b_move_0", "b_move_1", "b_move_2", "b_move_1"], "Ffall": ["b_jumpdown_1", "b_jumpdown_2"], "Fcrouch": ["b_crouch_1", "b_crouch_2"], "Rslide": ["b_slide"], "Fjump": ["b_jumpup_1", "b_jumpup_2", "b_jumpup_3"], "Oaa1": ["b_aa1_1", "b_aa1_2", "b_aa1_3", "b_aa1_3"], "Oaa2": ["b_aa2_1", "b_aa2_2", "b_aa2_3", "b_aa2_4", "b_aa2_5", "b_aa2_5"], "Oaa3": [ "b_aa3_1", "b_aa3_2", "b_aa3_3", "b_aa3_4", "b_aa3_5", "b_aa3_6", "b_aa3_6", "b_aa3_6" ], "Oaaa": ["b_aa2_2", "b_atkjumpdown", "b_atkjumpdown"], "Odmg": ["b_dmg_2", "b_dmg_2"], "D": ["b_gameover", "b_gameover"], } path = "Images/Blanchon" imagesBlanchon = load_imgs(imagesBlanchonList, path) blanchon_atkList = [ Atk("autoHit1", 0.5, 32, 32, load_imgs({"idle": ["particlehit"]}, path, 1), 10, 5, -1, 0, 0, 0, 225), Atk("autoHit2", 0.7, 32, 32, load_imgs({"idle": ["particlehit"]}, path, 1), 15, 5, -2, 0, 0, 0, 300), Atk("autoHit3", 0.7, 32, 32, load_imgs({"idle": ["particlehit"]}, path, 1), 15, 6, -16, 0, 0, 0, 500), Atk("EOF", 4, 32, 17, load_imgs({"idle": ["vector"]}, path), 15, 4, -1, 0, 4, 0, 2000), Atk("airAutoHit", 1, 64, 32, load_imgs({"idle": ["particlehit"]}, path, 1), 10, 5, 5, 0, 0, 0, 300) ] blanchon = Hero(200, 200, 64, 64, imagesBlanchon, 0.3, 0.7, 8, 6, WIDTH, 100.0, blanchon_atkList, difHard) sol = Platform( 0, HEIGHT - 70, WIDTH, 10, pygame.image.load("Images/plateformtest.png").convert_alpha(), 0.4) # INIT ENNEMIS foes = [] # INIT POLICE Mult = pygame.font.Font("Polices/Lady Radical.ttf", 25) Mult.set_bold(False) MultB = pygame.font.Font("Polices/Lady Radical.ttf", 40) MultB.set_bold(False) damageFont = pygame.font.Font("Polices/Lady Radical.ttf", 30) timerFont = pygame.font.Font("Polices/Lady Radical.ttf", 25) timerFont.set_bold(False) levelFont = pygame.font.Font("Polices/Lady Radical.ttf", 25) levelFont.set_bold(False) scoreFont = pygame.font.Font("Polices/Lady Radical.ttf", 25) levelFont.set_bold(False) clearFont = pygame.font.Font("Polices/Lady Radical.ttf", 30) clearFont.set_bold(False) clearLabel = clearFont.render("STAGE CLEAR", 1, (10, 200, 50)) # INIT MUSIQUE pygame.mixer.init() musicMob = "Music/mob.wav" musicBoss = "Music/boss.wav" # INIT VAR DE JEU damageArray = [] timerDamage = 300 score = 0 niveau = 1 tempsParSalve = 10.0 # INIT SYSTEM CLOCK clock = pygame.time.Clock() fps = 60 while not blanchon.isDead(): salve = 1 # INIT PLATEFORMES platforms = [ Platform(randint(100, 400), HEIGHT - 180, 100, 10, pygame.image.load("Images/plateform.png").convert_alpha(), 1), Platform(randint(100, 400), HEIGHT - 280, 100, 10, pygame.image.load("Images/plateform.png").convert_alpha(), 1) ] while salve < 6 and not blanchon.isDead(): i = 0 if salve < 5: # AJOUTER DES MOBS A FOES while i < int(niveau + salve / 5): mobId = randint(0, 3) if mobId == 0: foes.append( Ninja(randint(50, WIDTH - 100), HEIGHT - 300, WIDTH, 1 + niveau / 10)) elif mobId == 1: foes.append( Samurai(randint(50, WIDTH - 100), HEIGHT - 300, WIDTH, 1 + niveau / 10)) elif mobId == 2: foes.append( Archer(randint(50, WIDTH - 100), HEIGHT - 300, WIDTH, 1 + niveau / 10)) elif mobId == 3: foes.append( Corbeau(randint(50, WIDTH - 100), HEIGHT - 300, WIDTH, 1 + niveau / 10)) i += 1 else: # AJOUTER UN BOSS A FOES while i < 1 + int(niveau / 5): if (niveau + i) % 2 == 0: foes.append(Demon(500, 350, WIDTH, 1 + niveau / 10)) elif (niveau + i) % 2 == 1: foes.append(Moine(500, 350, WIDTH, 1 + niveau / 10)) i += 1 niveauLabel = levelFont.render(f"{niveau} - {salve}", 1, (250, 250, 250)) timer = tempsParSalve timeSave = pygame.time.get_ticks() if salve == 5: pygame.mixer.music.load(musicBoss) pygame.mixer.music.play(-1) elif salve == 1: pygame.mixer.music.load(musicMob) pygame.mixer.music.set_volume(0.4) pygame.mixer.music.play(-1) # BOUCLE DE JEU ========================================================================================= while len(foes) > 0 and (timer > 0.0 or salve >= 4) and not blanchon.isDead(): # GESTION TIMER----------------------------------------------------------------- if timer <= 0.0: timer = 0 else: timer = timer - (pygame.time.get_ticks() - timeSave) / 1000.0 timeSave = pygame.time.get_ticks() # render text if salve != 5: timerLabel = timerFont.render(f"{timer:.1f} sec", 1, (50, 100, 200)) else: timerLabel = timerFont.render("BOSS", 1, (50, 100, 200)) scoreLabel = scoreFont.render(f"Score : {int(score)}", 1, (200, 200, 100)) clock.tick(fps) # GESTION EVENT------------------------------------------------------------------ for event in pygame.event.get(): if event.type == pygame.QUIT: # si l'utilisateur clique sur la croix sys.exit() # on ferme la fenêtre if event.type == pygame.KEYDOWN: blanchon.key_down(event) if event.type == pygame.KEYUP: blanchon.key_up(event) # GESTION DU DECORS-------------------------------------------------------------- # Fond fenetre.blit(fond_e, (0, 0)) # timer fenetre.blit(timerLabel, (490, 660)) fenetre.blit(niveauLabel, (500, 690)) # Plateformes nbPlatf = len(platforms) for i in range(0, nbPlatf): fenetre.blit(platforms[i].get_img(), platforms[i].get_rect()) # GESTION DU HERO---------------------------------------------------------------- # Affichage Multiplicateur de dégats Multipl = Mult.render("Mult : ", 1, (255, 255, 0)) combo = blanchon.get_combo() if combo < 2: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (255, 255, 0)) elif combo < 3: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (0, 0, 255)) elif combo < 4: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (255, 0, 255)) else: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (255, 0, 0)) fenetre.blit(Multipl, (700, 660)) fenetre.blit(MultiplCombo, (800, 650)) # Affichage du score fenetre.blit(scoreLabel, (700, 690)) # CoolDown Attaque de Blanchon colorRect = (125, 125, 125, 128) if not blanchon.get_onGround(): cd = blanchon_atkList[4].get_cd() if cd > 0: pygame.draw.rect(fenetre, (0, 0, 0), (95, 655, 60, 60)) else: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) tailleRect1 = 60 * cd / blanchon_atkList[4].get_maxCd() posRect1 = 715 - tailleRect1 fenetre.blit(blanchonAaMidAir, (100, 660)) CdAH = damageFont.render(f"{cd:.1f}" if cd else "", 1, (255, 0, 0)) elif blanchon.get_autoHitTimer3() > 0: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) fenetre.blit(blanchonAa3, (100, 660)) tailleRect1 = 60 * blanchon.get_autoHitTimer3() / 3000 posRect1 = 715 - tailleRect1 CdAH = damageFont.render( f"{blanchon.get_autoHitTimer3()/1000:.1f}" if blanchon.get_autoHitTimer3() else "", 1, (255, 0, 0)) elif blanchon.get_autoHitTimer2() > 0: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) fenetre.blit(blanchonAa2, (100, 660)) tailleRect1 = 60 * blanchon.get_autoHitTimer2() / 3000 posRect1 = 715 - tailleRect1 CdAH = damageFont.render( f"{blanchon.get_autoHitTimer2()/1000:.1f}" if blanchon.get_autoHitTimer2() else "", 1, (255, 0, 0)) else: cd = blanchon_atkList[0].get_cd() if cd > 0: pygame.draw.rect(fenetre, (0, 0, 0), (95, 655, 60, 60)) else: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) fenetre.blit(blanchonAa1, (100, 660)) tailleRect1 = 60 * cd / blanchon_atkList[0].get_maxCd() posRect1 = 715 - tailleRect1 CdAH = damageFont.render(f"{cd:.1f}" if cd else "", 1, (255, 0, 0)) CaseAa = pygame.Surface((60, tailleRect1), pygame.SRCALPHA) CaseAa.fill(colorRect) fenetre.blit(CaseAa, (95, posRect1)) fenetre.blit(CdAH, (110, 670)) if blanchon_atkList[3].get_cd() > 0: pygame.draw.rect(fenetre, (0, 0, 0), (175, 655, 60, 60)) pygame.draw.rect(fenetre, (255, 255, 255), (180, 660, 50, 50)) else: pygame.draw.rect(fenetre, (200, 200, 50), (175, 655, 60, 60)) pygame.draw.rect(fenetre, (255, 255, 255), (180, 660, 50, 50)) fenetre.blit(blanchonVector, (189, 677)) tailleRect2 = 60 * blanchon_atkList[3].get_cd( ) / blanchon_atkList[3].get_maxCd() posRect2 = 715 - tailleRect2 CaseAa = pygame.Surface((60, tailleRect2), pygame.SRCALPHA) CaseAa.fill((125, 125, 125, 128)) fenetre.blit(CaseAa, (175, posRect2)) CdProj = damageFont.render( f"{blanchon_atkList[3].get_cd():.1f}", 1, (255, 0, 0)) if blanchon_atkList[3].get_cd() > 0: fenetre.blit(CdProj, (190, 670)) # Teste Hero => Plateforme heroOnGround = blanchon.isOnGround() blanchon.setOnAir() blanchon.testPlatform(sol) for i in range(0, nbPlatf): blanchon.testPlatform(platforms[i]) # Le hero est descendu d'une plateforme if heroOnGround and not blanchon.isOnGround(): blanchon.giveDoubleJump() # On lui donne un saut blanchon.update(blanchon, fps) # AFFICHAGE DES DEGATS---------------------------------------------------------- i = 0 while i < len(damageArray): if damageArray[i][2] > 0: fenetre.blit(damageArray[i][0], damageArray[i][1]) damageArray[i][2] = damageArray[i][2] - (1000 / fps) i += 1 else: damageArray.pop(i) # GESTION DES MOBS--------------------------------------------------------------- # Teste Mob => Plateforme && Atk Hero => Mob nbAtkHero = len(blanchon.get_AtkEffectList()) i = 0 while i < len(foes): foes[i].nextImg(fps) fenetre.blit(foes[i].get_img(), foes[i].get_rect()) pygame.draw.rect(fenetre, (0, 0, 0), (foes[i].get_rect().x, foes[i].get_rect().y - 10, 60, 6)) pygame.draw.rect( fenetre, (255, 0, 0), (foes[i].get_rect().x, foes[i].get_rect().y - 10, int( max( min( foes[i].get_hp() / foes[i].get_hpMax() * 60, 60), 0)), 6)) foes[i].setOnAir() foes[i].testPlatform(sol) for j in range(0, nbPlatf): foes[i].testPlatform(platforms[j]) # Check si le mob i se fait toucher par l'atk de hero k for k in range(0, nbAtkHero): hpBefore = foes[i].get_hp() foes[i].testAtkEffect(blanchon.get_AtkEffectList()[k]) degats = foes[i].get_hp() - hpBefore if degats < 0.0: damageArray.append([ damageFont.render(f"{degats:.1f}", 1, (50, 150, 255)), (foes[i].get_x(), foes[i].get_y() - 40), timerDamage ]) nbAtkFoe = len(foes[i].get_AtkEffectList()) for l in range(0, nbAtkFoe): hpBefore = blanchon.get_hp() blanchon.testAtkEffect(foes[i].get_AtkEffectList()[l]) degats = blanchon.get_hp() - hpBefore if degats < 0: damageArray.append([ damageFont.render(f"{degats:.1f}", 1, (255, 0, 0)), (blanchon.get_x(), blanchon.get_y() - 40), timerDamage ]) fenetre.blit(foes[i].get_AtkEffectList()[l].get_img(), foes[i].get_AtkEffectList()[l].get_rect()) foes[i].update(blanchon, fps) if foes[i].get_hp() <= 0: # AJOUT DES POINTS AU SCORE score += foes[i].get_hpMax() * foes[i].get_hpMax() foes.pop(i) else: i += 1 for i in range(0, nbAtkHero): fenetre.blit(blanchon.get_AtkEffectList()[k].get_img(), blanchon.get_AtkEffectList()[k].get_rect()) # Affichage Hero blanchon.nextImg(fps) fenetre.blit(blanchon.get_img(), blanchon.get_rect()) pygame.draw.rect( fenetre, (0, 0, 0), (blanchon.get_rect().x, blanchon.get_rect().y - 10, 60, 6)) pygame.draw.rect( fenetre, (0, 255, 0), (blanchon.get_rect().x, blanchon.get_rect().y - 10, int( max( blanchon.get_hp() / float(blanchon.get_hpMax()) * 60, 0)), 6)) pygame.display.flip() # AJOUTE DES POINTS AU SCORE score += (tempsParSalve - timer) * 500 salve += 1 # ON FAIT UNE PAUSE ENTRE CHAQUE NIVEAU if not blanchon.isDead(): timePause = 3000.0 timeStart = pygame.time.get_ticks() while timePause > 0.0: clock.tick(fps) timePause = timePause - pygame.time.get_ticks() + timeStart timeStart = pygame.time.get_ticks() fenetre.blit(fond_e, (0, 0)) for i in range(0, len(foes)): foes[i].update(blanchon, fps) fenetre.blit(foes[i].get_img(), foes[i].get_rect()) blanchon.setOnAir() blanchon.testPlatform(sol) for i in range(0, len(blanchon.get_AtkEffectList())): blanchon.get_AtkEffectList()[i].update(blanchon, fps) fenetre.blit(blanchon.get_AtkEffectList()[i].get_img(), blanchon.get_AtkEffectList()[i].get_rect()) blanchon.update(blanchon, fps) fenetre.blit(blanchon.get_img(), blanchon.get_rect()) fenetre.blit(clearLabel, (400, 300)) pygame.display.flip() niveau += 1 dieMenu = DieMenu(fenetre, ("Rejouer", "Menu"), name, score) dieMenu.run(difHard) pygame.display.flip()
def detect_half_rest(self, half_rest_dir: str) -> None: half_rest_imgs = load_imgs(half_rest_dir) detector = Detector(self, half_rest_imgs, self._threshold_half_rest) self._half_rest_boxes = detector.detect() draw_boxes('half_rest_boxes_img.png', self._img_rgb, self._half_rest_boxes)
os.environ['CUDA_VISIBLE_DEVICES'] = '1' # vram limit for eficiency config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) # define class names classes = ['lecoq', 'crocs', 'vans', 'nike', 'adidas', 'reebok', 'sbenu', 'puma', 'drmartens', 'zeepseen', 'descente', 'converse', 'newbalance', 'barefoot'] # define our image size (width, height, channels) target_size = (224, 224) # load unprocessed images data_x, data_y = load_imgs(datapath='/home/tkdrlf9202/Datasets/shoes_classification', classes=classes, target_size=target_size) print(data_x.shape) # preprocess images for the model data_x = preprocess_input(data_x) # preprocess labels with scikit-learn LabelEncoder label_encoder = LabelEncoder() label_encoder.fit(data_y) data_y_int = label_encoder.transform(data_y) # calculate class weight cls_weight = class_weight.compute_class_weight('balanced', np.unique(data_y_int), data_y_int) # split the data to tran & valid data data_x_train, data_x_valid, data_y_train, data_y_valid = train_test_split(data_x, data_y_int,
def __init__(self, config): screen_width, screen_height = config.screen_width, config.screen_height self.dims = (screen_width, screen_height) self.test_batch = config.test_batch self.test_in = 'test_images/' + config.dataset + '_in/' self.test_gt = 'test_images/' + config.dataset + '_gt/' self._screen = None self.reward = 0 self.terminal = True self.stop_step = config.stop_step self.reward_func = config.reward_func # test data list_in = [self.test_in + name for name in os.listdir(self.test_in)] list_in.sort() list_gt = [self.test_gt + name for name in os.listdir(self.test_gt)] list_gt.sort() self.data_all, self.label_all = load_imgs(list_in, list_gt) self.test_total = len(list_in) self.test_cur = 0 # BGR --> RGB, swap H and W # This is because the data for tools training are in a different format # You don't need to do so with your own tools temp = self.data_all.copy() self.data_all[:, :, :, 0] = temp[:, :, :, 2] self.data_all[:, :, :, 2] = temp[:, :, :, 0] self.data_all = np.swapaxes(self.data_all, 1, 2) temp = self.label_all.copy() self.label_all[:, :, :, 0] = temp[:, :, :, 2] self.label_all[:, :, :, 2] = temp[:, :, :, 0] self.label_all = np.swapaxes(self.label_all, 1, 2) self.data_test = self.data_all[0:min(self.test_batch, self.test_total), ...] self.label_test = self.label_all[ 0:min(self.test_batch, self.test_total), ...] # reward functions self.rewards = {'step_psnr_reward': step_psnr_reward} self.reward_function = self.rewards[self.reward_func] # base_psnr (input psnr) self.base_psnr = 0. for k in range(len(self.data_all)): self.base_psnr += psnr_cal(self.data_all[k, ...], self.label_all[k, ...]) self.base_psnr /= len(self.data_all) self.data = np.array([[[[0]]]]) self._data_index = 0 self._data_len = len(self.data) # build toolbox self.action_size = 12 + 1 toolbox_path = 'toolbox/' self.graphs = [] self.sessions = [] self.inputs = [] self.outputs = [] for idx in range(12): g = tf.Graph() with g.as_default(): # load graph saver = tf.train.import_meta_graph(toolbox_path + 'tool%02d' % (idx + 1) + '.meta') # input data input_data = g.get_tensor_by_name('Placeholder:0') self.inputs.append(input_data) # get the output output_data = g.get_tensor_by_name('sum:0') self.outputs.append(output_data) # save graph self.graphs.append(g) sess = tf.Session(graph=g, config=tf.ConfigProto(log_device_placement=True)) with g.as_default(): with sess.as_default(): saver.restore(sess, toolbox_path + 'tool%02d' % (idx + 1)) self.sessions.append(sess)
gamma = 2 # 0.75 pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred)) pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred)) return -K.sum(alpha * K.pow(1. - pt_1, gamma) * K.log(pt_1)) - K.sum( (1 - alpha) * K.pow(pt_0, gamma) * K.log(1. - pt_0)) model = models.lite_conv(height, width, loss=weighted_binary_crossentropy, optimizer=Adam(lr=1e-4), metrics=['accuracy'], channels=1) print("Loading images") imgs, masks, labels = load_imgs(random.sample(range(0, 140), 20)) #随机产生不重复整数列表 if os.path.exists("saved_models/{}_1.h5".format(model_name)): print('loading model') model = load_model("saved_models/{}_1.h5".format(model_name), custom_objects={ 'weighted_binary_crossentropy': weighted_binary_crossentropy }) print('Fit model') model_checkpoint = ModelCheckpoint(model_filename, monitor='val_acc', save_best_only=True, verbose=1) model.summary()
dtype = torch.float device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') if device.type == 'cuda': # # comment this if we want reproducibility # torch.backends.cudnn.benchmark = True # torch.backends.cudnn.enabled = True # # this might affect performance but allows reproducibility torch.backends.cudnn.enabled = False torch.backends.cudnn.deterministic = True # define dataset trf_train, trf_test = get_transforms() loader_train, loader_val = get_dataloaders(trf_train) mturk_images, _ = utils.load_imgs(args.test_dir, trf_test) # create model model = FTModel( models.resnet34(pretrained=True), layers_to_remove=1, num_features=args.emb_size, num_classes=args.num_classes, ) model = model.to(device, dtype) # define loss function criterion = TripletLossHuman(margin=args.margin, unit_norm=True, device=device, seed=args.seed)
def detect_flat_sign(self, flat_sign_dir: str) -> None: flat_sign_imgs = load_imgs(flat_sign_dir) detector = Detector(self, flat_sign_imgs, self._threshold_flat_sign) self._flat_sign_boxes = detector.detect() draw_boxes('flat_sign_boxes_img.png', self._img_rgb, self._flat_sign_boxes)
def detect_whole_note(self, whole_note_dir: str) -> None: whole_note_imgs = load_imgs(whole_note_dir) detector = Detector(self, whole_note_imgs, self._threshold_whole_note) self._whole_note_boxes = detector.detect() draw_boxes('whole_note_boxes_img.png', self._img_rgb, self._whole_note_boxes)
def main(): training_path = '/data/cat/train' test_path = '/data/cat/test' train_data, labels = utils.load_imgs(training_path, file_ext='.jpg', neg_folder='non-cat') train_data = train_data.astype(np.float32) s = time.time() train_data, masks = utils.normalize_img_cv(train_data) #train_data = utils.normalize_img_max(train_data) e = time.time() print('\n\n normalize\n\n', e - s) print('train_data ', train_data.shape) s = time.time() #train_data = utils.normalize_img_cv(train_data) #train_data = utils.normalize_img_max(train_data) e = time.time() print('normalize', e - s) #return counter = collections.Counter(labels) fc = TrainFeatureMapGenerator(train_data) fc.set_min_feture(2, 2) fc.set_max_feture(2, 2) fc.caculate_features_all() s = time.time() fc.prepare_to_train(do_argsort=False) e = time.time() print('prepare to train', e - s) print(fc.fmap.shape) w = Weights(labels, init_neg_w=1.0, init_pos_w=1.19) #w = Weights(labels) print(w.positive_num, w.negative_num) #uw = UnitWeights(labels) wt = WeakClassifierTrainer(fc.fmap, w, labels, tmp_val=fc.tmp_val, argsorted=False) #wt = WeakClassifierTrainer(fc.fmap, uw, labels, tmp_val=fc.tmp_val, argsorted=False) wc = [] s = time.time() for i in range(1): r = wt.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) print(len(wc)) for item in wc: print(item) print('\n\n') sc = StrongClassifier(wc) sc.setImg(train_data, labels=labels) ir = sc.inference() iv = InferenceVerifier(labels, ir['faces']) vr = iv.verify(verbose=True)
def main(experiment_yml_path): with open(experiment_yml_path, 'r') as f: settings = yaml.load(f) experiment_name, _ = os.path.splitext( os.path.basename(experiment_yml_path)) print('->', experiment_name) for k, v in settings.items(): print(k, '=', v) #----------------------- experiment settings ------------------------ IMG_SIZE = settings['IMG_SIZE'] BATCH_SIZE = settings['BATCH_SIZE'] NUM_EPOCHS = settings['NUM_EPOCHS'] data_augmentation = settings['data_augmentation'] # string dataset_dir = settings['dataset_dir'] save_model_path = settings['save_model_path'] ## NOTE history_path = settings['history_path'] ## NOTE eval_result_dirpath = os.path.join(settings['eval_result_parent_dir'], experiment_name) # optional settings sqr_crop_dataset = settings.get('sqr_crop_dataset') kernel_init = settings.get('kernel_init') num_maxpool = settings.get('num_maxpool') num_filters = settings.get('num_filters') overlap_factor = settings.get('overlap_factor') #loaded_model = save_model_path ## NOTE loaded_model = None #-------------------------------------------------------------------- #-------------------------------------------------------------------- train_dir = os.path.join(dataset_dir, 'train') valid_dir = os.path.join(dataset_dir, 'valid') test_dir = os.path.join(dataset_dir, 'test') output_dir = os.path.join(dataset_dir, 'output') origin_dir = os.path.join(output_dir, 'image') answer_dir = os.path.join(output_dir, 'label') result_dir = os.path.join(output_dir, 'result') #-------------------------------------------------------------------- #-------------------- ready to generate batch ----------------------- train_imgs = list(load_imgs(os.path.join(train_dir, 'image'))) train_masks = list(load_imgs(os.path.join(train_dir, 'label'))) valid_imgs = list(load_imgs(os.path.join(valid_dir, 'image'))) valid_masks = list(load_imgs(os.path.join(valid_dir, 'label'))) test_imgs = list(load_imgs(os.path.join(test_dir, 'image'))) test_masks = list(load_imgs(os.path.join(test_dir, 'label'))) if overlap_factor is None: overlap_factor = 2 #calc mean h,w of dataset tr_h, tr_w = sum(map(lambda img: np.array(img.shape[:2]), train_imgs)) / len(train_imgs) vl_h, vl_w = sum(map(lambda img: np.array(img.shape[:2]), valid_imgs)) / len(valid_imgs) te_h, te_w = sum(map(lambda img: np.array(img.shape[:2]), test_imgs)) / len(test_imgs) #print(tr_h,tr_w, '|', vl_h,vl_w, '|', te_h,te_w) train_num_sample = int( (tr_h / IMG_SIZE) * (tr_w / IMG_SIZE) * overlap_factor) valid_num_sample = int( (vl_h / IMG_SIZE) * (vl_w / IMG_SIZE) * overlap_factor) test_num_sample = int( (te_h / IMG_SIZE) * (te_w / IMG_SIZE) * overlap_factor) #print(train_num_sample,valid_num_sample,test_num_sample) train_steps_per_epoch = modulo_ceil( len(train_imgs), BATCH_SIZE) // BATCH_SIZE * train_num_sample valid_steps_per_epoch = modulo_ceil( len(valid_imgs), BATCH_SIZE) // BATCH_SIZE * valid_num_sample test_steps_per_epoch = modulo_ceil( len(test_imgs), BATCH_SIZE) // BATCH_SIZE * test_num_sample print('# train images =', len(train_imgs), '| train steps/epoch =', train_steps_per_epoch) print('# valid images =', len(valid_imgs), '| valid steps/epoch =', valid_steps_per_epoch) print('# test images =', len(test_imgs), '| test steps/epoch =', test_steps_per_epoch) if data_augmentation == 'bioseg': aug = augmenter(BATCH_SIZE, IMG_SIZE, 1, crop_before_augs=[ iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.Affine(rotate=(-180, 180), mode='reflect'), ], crop_after_augs=[ iaa.ElasticTransformation(alpha=(100, 200), sigma=14, mode='reflect'), ]) elif data_augmentation == 'manga_gb': aug = augmenter(BATCH_SIZE, IMG_SIZE, 1, crop_before_augs=[ iaa.Affine(rotate=(-3, 3), shear=(-3, 3), scale={ 'x': (0.8, 1.5), 'y': (0.8, 1.5) }, mode='reflect'), ]) elif data_augmentation == 'no_aug': aug = augmenter(BATCH_SIZE, IMG_SIZE, 1) if sqr_crop_dataset: aug = None my_gen = batch_gen(train_imgs, train_masks, BATCH_SIZE, aug) valid_gen = batch_gen(valid_imgs, valid_masks, BATCH_SIZE, aug) test_gen = batch_gen(test_imgs, test_masks, BATCH_SIZE, aug) #-------------------------------------------------------------------- ''' # DEBUG for ims,mas in my_gen: for im,ma in zip(ims,mas): cv2.imshow('i',im) cv2.imshow('m',ma); cv2.waitKey(0) ''' #---------------------------- train model --------------------------- if kernel_init is None: kernel_init = 'he_normal' if num_maxpool is None: num_maxpool = 4 if num_filters is None: num_filters = 64 LEARNING_RATE = 1.0 model = unet(pretrained_weights=loaded_model, input_size=(IMG_SIZE, IMG_SIZE, 1), kernel_init=kernel_init, num_filters=num_filters, num_maxpool=num_maxpool, lr=LEARNING_RATE) model_checkpoint = ModelCheckpoint(save_model_path, monitor='val_loss', verbose=1, save_best_only=True) train_timer = ElapsedTimer(experiment_yml_path + ' training') history = model.fit_generator(my_gen, epochs=NUM_EPOCHS, steps_per_epoch=train_steps_per_epoch, validation_steps=valid_steps_per_epoch, validation_data=valid_gen, callbacks=[model_checkpoint]) train_time_str = train_timer.elapsed_time() #-------------------------------------------------------------------- #--------------------------- save results --------------------------- origins = list(load_imgs(origin_dir)) answers = list(load_imgs(answer_dir)) assert len(origins) == len(answers) num_imgs = len(origins) if not sqr_crop_dataset: aug_det = augmenter(num_imgs, IMG_SIZE, 1).to_deterministic() # no augmentation! origins = aug_det.augment_images(origins) answers = aug_det.augment_images(answers) predictions = model.predict_generator( (img.reshape(1, IMG_SIZE, IMG_SIZE, 1) for img in origins), num_imgs, verbose=1) evaluator.save_img_tuples(zip(origins, answers, predictions), result_dir) test_metrics = model.evaluate_generator(test_gen, steps=test_steps_per_epoch) K.clear_session() #print(model.metrics_names) #print(test_metrics) print('test set: loss =', test_metrics[0], '| IoU =', test_metrics[1]) #-------------------------------------------------------------------- #------------------- evaluation and save results -------------------- with open(history_path, 'w') as f: f.write( yaml.dump( dict( loss=list(map(np.asscalar, history.history['loss'])), acc=list(map(np.asscalar, history.history['mean_iou'])), val_loss=list(map(np.asscalar, history.history['val_loss'])), val_acc=list( map(np.asscalar, history.history['val_mean_iou'])), test_loss=np.asscalar(test_metrics[0]), test_acc=np.asscalar(test_metrics[1]), train_time=train_time_str, ))) modulo = 2**num_maxpool evaluator.eval_and_save_result( dataset_dir, save_model_path, eval_result_dirpath, files_2b_copied=[history_path, experiment_yml_path], num_filters=num_filters, num_maxpool=num_maxpool, modulo=modulo)
def main(self): pygame.init() WIDTH = 1280 HEIGHT = 720 fenetre = pygame.display.set_mode((WIDTH, HEIGHT), pygame.RESIZABLE) fond_e = pygame.transform.scale( pygame.image.load( "Images/Background/niveauRecurciforce.png").convert(), (1280, 720)) blanchonAa1 = pygame.image.load("Images/Spell/aa1.png").convert() blanchonAa2 = pygame.image.load("Images/Spell/aa2.png").convert() blanchonAa3 = pygame.image.load("Images/Spell/aa3.png").convert() blanchonAaMidAir = pygame.image.load("Images/Spell/aaMidAir.png").convert() blanchonVector = pygame.image.load("Images/Spell/vector.png").convert() imagesBlanchonList = { "Ridle": ["b_idle_1", "b_idle_2"], "Rmove": ["b_move_0", "b_move_1", "b_move_2", "b_move_1"], "Ffall": ["b_jumpdown_1", "b_jumpdown_2"], "Fcrouch": ["b_crouch_1", "b_crouch_2"], "Rslide": ["b_slide"], "Fjump": ["b_jumpup_1", "b_jumpup_2", "b_jumpup_3"], "Oaa1": ["b_aa1_1", "b_aa1_2", "b_aa1_3", "b_aa1_3"], "Oaa2": ["b_aa2_1", "b_aa2_2", "b_aa2_3", "b_aa2_4", "b_aa2_5", "b_aa2_5"], "Oaa3": [ "b_aa3_1", "b_aa3_2", "b_aa3_3", "b_aa3_4", "b_aa3_5", "b_aa3_6", "b_aa3_6", "b_aa3_6" ], "Oaaa": ["b_aa2_2", "b_atkjumpdown", "b_atkjumpdown"], "Odmg": ["b_dmg_2", "b_dmg_2"], "D": ["b_gameover", "b_gameover"], } path = "Images/Blanchon" imagesBlanchon = load_imgs(imagesBlanchonList, path) blanchon_atkList = [ Atk("autoHit1", 0.5, 32, 32, load_imgs({"idle": ["particlehit"]}, path), 10, 5, -1, 0, 0, 0, 225), Atk("autoHit2", 0.7, 32, 32, load_imgs({"idle": ["particlehit"]}, path), 15, 5, -2, 0, 0, 0, 300), Atk("autoHit3", 0.7, 32, 32, load_imgs({"idle": ["particlehit"]}, path), 15, 6, -16, 0, 0, 0, 500), Atk("EOF", 4, 32, 17, load_imgs({"idle": ["vector"]}, path), 15, 4, -1, 0, 4, 0, 2000), Atk("airAutoHit", 1, 64, 32, load_imgs({"idle": ["particlehit"]}, path), 10, 5, 5, 0, 0, 0, 300) ] blanchon = Hero(200, 200, 64, 64, imagesBlanchon, 0.3, 0.7, 8, 6, WIDTH, 100.0, blanchon_atkList) sol = Platform( 0, HEIGHT - 70, WIDTH, 10, pygame.image.load("Images/plateformtest.png").convert_alpha(), 0.4) # INIT PLATEFORMES platforms = [ Platform(100, HEIGHT - 180, 100, 10, pygame.image.load("Images/plateform.png").convert_alpha(), 1), Platform(350, HEIGHT - 280, 100, 10, pygame.image.load("Images/plateform.png").convert_alpha(), 1) ] # INIT ENNEMIS foes = [SacDeSable(600, 500, WIDTH, 1)] # INIT SYSTEM CLOCK clock = pygame.time.Clock() fps = 60 Mult = pygame.font.Font("Polices/Lady Radical.ttf", 25) Mult.set_bold(False) MultB = pygame.font.Font("Polices/Lady Radical.ttf", 40) MultB.set_bold(True) damageFont = pygame.font.Font("Polices/Lady Radical.ttf", 30) # damageFont.set_bold(True) damageArray = [] timerDamage = 300 # TEXTE DU TUTO------------------------------------------------------------------ self.myfontMini = pygame.font.Font("Polices/Lady Radical.ttf", 15) self.myfont = pygame.font.Font("Polices/Lady Radical.ttf", 25) fleches = self.myfont.render( "Les fleches directionnelles servent a se deplacer", 1, (200, 200, 0)) atkDeBase = self.myfont.render( "'A' (Q sous Windows) permet de donner des coups au corps a corps", 1, (200, 200, 0)) atkDistance = self.myfont.render( "'Z' (W sous Windows) permet de lancer des projectiles", 1, (200, 200, 0)) combol = self.myfont.render( "Un combo est possible en realisant 3 attaques basiques successives", 1, (200, 200, 0)) dbSaut = self.myfont.render("Le double saut est possible", 1, (200, 200, 0)) quit1 = self.myfontMini.render("Appuyer sur 'Entree' pour ", 1, (200, 200, 0)) quit2 = self.myfontMini.render("retourner au menu principal ", 1, (200, 200, 0)) while 1: clock.tick(fps) # GESTION EVENT------------------------------------------------------------------ for event in pygame.event.get(): if event.type == pygame.QUIT: # si l'utilisateur clique sur la croix sys.exit() # on ferme la fenêtre if event.type == pygame.KEYDOWN: exit_game(event.key) blanchon.key_down(event) if event.type == pygame.KEYUP: blanchon.key_up(event) # GESTION DU DECORS-------------------------------------------------------------- # Fond fenetre.blit(fond_e, (0, 0)) self.screen.blit(fleches, (600, 50)) self.screen.blit(atkDeBase, (600, 80)) self.screen.blit(atkDistance, (600, 110)) self.screen.blit(combol, (600, 140)) self.screen.blit(dbSaut, (600, 170)) self.screen.blit(quit1, (1100, 600)) self.screen.blit(quit2, (1100, 620)) # Plateformes nbPlatf = len(platforms) for i in range(0, nbPlatf): fenetre.blit(platforms[i].get_img(), platforms[i].get_rect()) # GESTION DU HERO---------------------------------------------------------------- # Affichage Multiplicateur de dégats Multipl = Mult.render("Mult : ", 1, (255, 255, 0)) combo = blanchon.get_combo() if combo < 2: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (255, 255, 0)) elif combo < 3: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (0, 0, 255)) elif combo < 4: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (255, 0, 255)) else: MultiplCombo = MultB.render(f"{combo:.2f}", 1, (255, 0, 0)) fenetre.blit(Multipl, (700, 680)) fenetre.blit(MultiplCombo, (800, 670)) # CoolDown Attaque de Blanchon colorRect = (125, 125, 125, 128) if not blanchon.get_onGround(): cd = blanchon_atkList[4].get_cd() if cd > 0: pygame.draw.rect(fenetre, (0, 0, 0), (95, 655, 60, 60)) else: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) tailleRect1 = 60 * cd / blanchon_atkList[4].get_maxCd() posRect1 = 715 - tailleRect1 fenetre.blit(blanchonAaMidAir, (100, 660)) CdAH = damageFont.render(f"{cd:.1f}", 1, (255, 0, 0)) elif blanchon.get_autoHitTimer3() > 0: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) fenetre.blit(blanchonAa3, (100, 660)) tailleRect1 = 60 * blanchon.get_autoHitTimer3() / 3000 posRect1 = 715 - tailleRect1 CdAH = damageFont.render( f"{blanchon.get_autoHitTimer3()/1000:.1f}", 1, (255, 0, 0)) elif blanchon.get_autoHitTimer2() > 0: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) fenetre.blit(blanchonAa2, (100, 660)) tailleRect1 = 60 * blanchon.get_autoHitTimer2() / 3000 posRect1 = 715 - tailleRect1 CdAH = damageFont.render( f"{blanchon.get_autoHitTimer2()/1000:.1f}", 1, (255, 0, 0)) else: cd = blanchon_atkList[0].get_cd() if cd > 0: pygame.draw.rect(fenetre, (0, 0, 0), (95, 655, 60, 60)) else: pygame.draw.rect(fenetre, (200, 200, 50), (95, 655, 60, 60)) fenetre.blit(blanchonAa1, (100, 660)) tailleRect1 = 60 * cd / blanchon_atkList[0].get_maxCd() posRect1 = 715 - tailleRect1 CdAH = damageFont.render(f"{cd:.1f}", 1, (255, 0, 0)) CaseAa = pygame.Surface((60, tailleRect1), pygame.SRCALPHA) CaseAa.fill(colorRect) fenetre.blit(CaseAa, (95, posRect1)) if cd > 0: fenetre.blit(CdAH, (110, 670)) if blanchon_atkList[3].get_cd() > 0: pygame.draw.rect(fenetre, (0, 0, 0), (175, 655, 60, 60)) pygame.draw.rect(fenetre, (255, 255, 255), (180, 660, 50, 50)) else: pygame.draw.rect(fenetre, (200, 200, 50), (175, 655, 60, 60)) pygame.draw.rect(fenetre, (255, 255, 255), (180, 660, 50, 50)) fenetre.blit(blanchonVector, (189, 677)) tailleRect2 = 60 * blanchon_atkList[3].get_cd( ) / blanchon_atkList[3].get_maxCd() posRect2 = 715 - tailleRect2 CaseAa = pygame.Surface((60, tailleRect2), pygame.SRCALPHA) CaseAa.fill((125, 125, 125, 128)) fenetre.blit(CaseAa, (175, posRect2)) CdProj = damageFont.render(f"{blanchon_atkList[3].get_cd():.1f}", 1, (255, 0, 0)) if blanchon_atkList[3].get_cd() > 0: fenetre.blit(CdProj, (190, 670)) # Teste Hero => Plateforme heroOnGround = blanchon.isOnGround() blanchon.setOnAir() blanchon.testPlatform(sol) for i in range(0, nbPlatf): blanchon.testPlatform(platforms[i]) # Le hero est descendu d'une plateforme if heroOnGround and not blanchon.isOnGround(): blanchon.giveDoubleJump() # On lui donne un saut blanchon.update(blanchon, fps) # AFFICHAGE DES DEGATS---------------------------------------------------------- i = 0 while i < len(damageArray): if damageArray[i][2] > 0: fenetre.blit(damageArray[i][0], damageArray[i][1]) damageArray[i][2] = damageArray[i][2] - (1000 / fps) i += 1 else: damageArray.pop(i) # GESTION DES MOBS--------------------------------------------------------------- # Teste Mob => Plateforme && Atk Hero => Mob nbAtkHero = len(blanchon.get_AtkEffectList()) i = 0 while i < len(foes): foes[i].nextImg(fps) fenetre.blit(foes[i].get_img(), foes[i].get_rect()) pygame.draw.rect( fenetre, (0, 0, 0), (foes[i].get_rect().x, foes[i].get_rect().y - 10, 60, 6)) pygame.draw.rect( fenetre, (255, 0, 0), (foes[i].get_rect().x, foes[i].get_rect().y - 10, int( max( min( foes[i].get_hp() / float(foes[i].get_hpMax()) * 60, 60), 0)), 6)) foes[i].setOnAir() foes[i].testPlatform(sol) for j in range(0, nbPlatf): foes[i].testPlatform(platforms[j]) # Check si le mob i se fait toucher par l'atk de hero k for k in range(0, nbAtkHero): hpBefore = foes[i].get_hp() foes[i].testAtkEffect(blanchon.get_AtkEffectList()[k]) degats = foes[i].get_hp() - hpBefore foes[i].set_hp(degats) if degats < 0.0: damageArray.append([ damageFont.render(f"{degats:.1f}", 1, (50, 150, 255)), (foes[i].get_x(), foes[i].get_y() - 40), timerDamage ]) nbAtkFoe = len(foes[i].get_AtkEffectList()) for l in range(0, nbAtkFoe): hpBefore = blanchon.get_hp() blanchon.testAtkEffect(foes[i].get_AtkEffectList()[l]) degats = blanchon.get_hp() - hpBefore if degats < 0: damageArray.append([ damageFont.render(f"{degats:.1f}", 1, (255, 0, 0)), (blanchon.get_x(), blanchon.get_y() - 40), timerDamage ]) fenetre.blit(foes[i].get_AtkEffectList()[l].get_img(), foes[i].get_AtkEffectList()[l].get_rect()) foes[i].update(blanchon, fps) if foes[i].get_hp() <= 0: foes.pop(i) else: i += 1 for i in range(0, nbAtkHero): fenetre.blit(blanchon.get_AtkEffectList()[k].get_img(), blanchon.get_AtkEffectList()[k].get_rect()) # Affichage Hero blanchon.nextImg(fps) fenetre.blit(blanchon.get_img(), blanchon.get_rect()) pygame.draw.rect( fenetre, (0, 0, 0), (blanchon.get_rect().x, blanchon.get_rect().y - 10, 60, 6)) pygame.draw.rect( fenetre, (0, 255, 0), (blanchon.get_rect().x, blanchon.get_rect().y - 10, int( max( min(blanchon.get_hp() / float(blanchon.get_hpMax()) * 60, 60), 0)), 6)) pygame.display.flip()
def main(): training_path = '/data/daily/VJ/faces/train' test_path = '/data/daily/VJ/faces/test' train_data, labels = utils.load_imgs(training_path) train_data = train_data.astype(np.float32) print('train_data ', train_data.shape) s = time.time() #train_data = utils.normalize_img_cv(train_data) #train_data = utils.normalize_img_max(train_data) e = time.time() print('normalize', e - s) #return counter = collections.Counter(labels) fc = TrainFeatureMapGenerator(train_data) fc.set_min_feture(4, 4) fc.set_max_feture(4, 4) fc.caculate_features_all() s = time.time() fc.prepare_to_train(do_argsort=False) e = time.time() print('prepare to train', e - s) ''' img_idx = 0 c1 = fc.fmap[:,img_idx] print('c1.shape ', c1.shape, np.sum(c1), np.sum(np.abs(c1))) f_all = [] for i in tqdm(range(fc.fmap.shape[0])): _, fval, _ = fc.get_feature(img_idx, i) f_all.append(fval) f_all = np.asarray(f_all) print(f_all.shape, np.sum(f_all), np.sum(np.abs(f_all))) ''' w = Weights(labels) print(w.positive_num, w.negative_num) #uw = UnitWeights(labels) wt = WeakClassifierTrainer(fc.fmap, w, labels, tmp_val=fc.tmp_val, argsorted=False) #wt = WeakClassifierTrainer(fc.fmap, uw, labels, tmp_val=fc.tmp_val, argsorted=False) wc = [] s = time.time() for i in range(20): r = wt.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) print(len(wc)) for item in wc: print(item) print('\n\n') sc = strong_classifier(wc) tmp = train_data[0].astype(int) tmp = tmp.reshape(19, 19, 1) cv2.imwrite("0.jpg", tmp) #train_data = train_data[0:5,:,:] sc.setImg(train_data, labels=labels) false_samples = sc.inference() m = np.ones(w.w.shape[0]) fp = np.power(2, false_samples['false_positive']) fn = np.power(3, false_samples['false_negative']) m = m * fp m = m * fn w2 = Weights2(labels, multiplier=[m]) np.savetxt('m.txt', m, fmt='%f') np.savetxt('w2.txt', w2.w, fmt='%f') wt2 = WeakClassifierTrainer(fc.fmap, w2, labels, tmp_val=fc.tmp_val, argsorted=False) wc2 = [] for i in range(10): r = wt2.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc2.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) print(len(wc2)) for item in wc2: print(item) print('\n\n')
def detect_sharp_sign(self, sharp_sign_dir: str) -> None: sharp_sign_imgs = load_imgs(sharp_sign_dir) detector = Detector(self, sharp_sign_imgs, self._threshold_sharp_sign) self._sharp_sign_boxes = detector.detect() draw_boxes('sharp_sign_boxes_img.png', self._img_rgb, self._sharp_sign_boxes)
def main(): training_path = './train' test_path = './test' train_data, labels = utils.load_imgs(training_path, file_ext='.jpg', neg_folder='non-cat') train_data = train_data.astype(np.float32) s = time.time() train_data, masks = utils.normalize_img_cv(train_data) #train_data = utils.normalize_img_max(train_data) e = time.time() print('\n\n normalize\n\n', e - s) print('train_data ', train_data.shape) s = time.time() #train_data = utils.normalize_img_cv(train_data) #train_data = utils.normalize_img_max(train_data) e = time.time() print('normalize', e - s) #return counter = collections.Counter(labels) fc = TrainFeatureMapGenerator(train_data) fc.set_min_feture(2, 2) fc.set_max_feture(2, 2) fc.caculate_features_all() s = time.time() fc.prepare_to_train(do_argsort=False) e = time.time() print('prepare to train', e - s) print(fc.fmap.shape) w = Weights(labels, init_neg_w=1.0, init_pos_w=1.19) #w = Weights(labels) print(w.positive_num, w.negative_num) #uw = UnitWeights(labels) wt = WeakClassifierTrainer(fc.fmap, w, labels, tmp_val=fc.tmp_val, argsorted=False) #wt = WeakClassifierTrainer(fc.fmap, uw, labels, tmp_val=fc.tmp_val, argsorted=False) wc = [] s = time.time() for i in range(20): r = wt.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) print(len(wc)) for item in wc: print(item) print('\n\n') sc = StrongClassifier(wc, (24, 24)) sc.setImg(train_data, labels=labels) ir = sc.inference() iv = InferenceVerifier(labels, ir['faces']) #print('@@@@@@@@@@@@@@@@@@@@ iv ', ir['faces'].shape) vr = iv.verify(verbose=True) test_data, test_labels = utils.load_imgs(test_path, file_ext='.jpg', neg_folder='non-cat', max_=3000) test_data = test_data.astype(np.float32) test_data, masks = utils.normalize_img_cv(test_data, store=True) #------------------------------------------------------------------------------------ m = np.ones(w.w.shape[0]) fp = np.power(1.0, vr['false_positive']) fn = np.power(1.5, vr['false_negative']) m = m * fp m = m * fn w2 = Weights2(labels, init_neg_w=1.0, init_pos_w=3.0, multiplier=[m]) print( "\n\n\n======================================================================\n\n\n" ) fc.clean() fc.set_min_feture(4, 4) fc.set_max_feture(6, 6) fc.caculate_features_all() fc.prepare_to_train(do_argsort=False) wt2 = WeakClassifierTrainer(fc.fmap, w2, labels, tmp_val=fc.tmp_val, argsorted=False) wc2 = [] s = time.time() for i in range(20): r = wt2.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc2.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) m = np.ones(w.w.shape[0]) fp = np.power(1.0, vr['false_positive']) fn = np.power(1.5, vr['false_negative']) m = m * fp m = m * fn w3 = Weights2(labels, init_neg_w=1.0, init_pos_w=3.0, multiplier=[m]) #print("\n\n\n======================================================================\n\n\n") fc.clean() fc.set_min_feture(8, 8) fc.set_max_feture(8, 8) fc.caculate_features_all() fc.prepare_to_train(do_argsort=False) wt3 = WeakClassifierTrainer(fc.fmap, w3, labels, tmp_val=fc.tmp_val, argsorted=False) wc3 = [] s = time.time() for i in range(20): r = wt3.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc3.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) m = np.ones(w.w.shape[0]) fp = np.power(1.0, vr['false_positive']) fn = np.power(1.5, vr['false_negative']) m = m * fp m = m * fn w4 = Weights2(labels, init_neg_w=1.0, init_pos_w=3.0, multiplier=[m]) #print("\n\n\n======================================================================\n\n\n") fc.clean() fc.set_min_feture(10, 10) fc.set_max_feture(10, 10) fc.caculate_features_all() fc.prepare_to_train(do_argsort=False) wt4 = WeakClassifierTrainer(fc.fmap, w4, labels, tmp_val=fc.tmp_val, argsorted=False) wc4 = [] s = time.time() for i in range(20): r = wt4.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc4.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) m = np.ones(w.w.shape[0]) fp = np.power(1.0, vr['false_positive']) fn = np.power(1.5, vr['false_negative']) m = m * fp m = m * fn w5 = Weights2(labels, init_neg_w=1.0, init_pos_w=3.0, multiplier=[m]) #print("\n\n\n======================================================================\n\n\n") fc.clean() fc.set_min_feture(12, 12) fc.set_max_feture(12, 12) fc.caculate_features_all() fc.prepare_to_train(do_argsort=False) wt5 = WeakClassifierTrainer(fc.fmap, w5, labels, tmp_val=fc.tmp_val, argsorted=False) wc5 = [] s = time.time() for i in range(20): r = wt5.train() uid, fval, coord = fc.get_feature(r[0], r[1]) wc5.append((uid, fval, coord, r[2], r[3])) print('\n\n') e = time.time() print('train', e - s) wcs = [wc, wc2, wc3, wc4, wc5] np.savez_compressed('./StrongClassifier', sc=wcs) #csc = CascadedStrongClassifier(strong_clfs=wcs) csc = CascadedStrongClassifier() csc.load_model('./StrongClassifier.npz') cat_img = cv2.imread( '/data/daily/VJ/VJ_git/new_ranged_table/0625/VJ_git/checkin/cat.jpg') cat_img = cv2.cvtColor(cat_img, cv2.COLOR_BGR2GRAY) cat_img = cat_img.reshape(1, cat_img.shape[0], cat_img.shape[1]) print('cat_img', cat_img.shape) print( "======================================================================" ) r = csc.inference(cat_img) print( "======================================================================" ) if False: r = csc.inference(test_data) res = r['positive'] print('^^^^', type(res)) iv2 = InferenceVerifier(test_labels, res) vr2 = iv2.verify(verbose=True) print( "\n\n\n======================================================================\n\n\n" ) #------------------------------------------------------------------------------------ '''
i, idx_start, idx_end = 0, 0, 0 while idx_end < len(imgs): idx_start = offset * i idx_end = min(offset * (i + 1), len(imgs)) # forward through the CNN and get the embeddings _, embs = model.forward(imgs[idx_start:idx_end]) partial_embs.append(embs.detach().cpu()) # update index i += 1 # move it to numpy and return embs = torch.cat(partial_embs, 0).numpy() return embs if __name__ == '__main__': weights_path = 'data/model_best.pth.tar' imgs_path = 'data/havran1_ennis_298x298_LDR' # we will store the obtained feature vectors in this path embs_path = 'data/embs_havran_ennis.mat' model = utils.load_model(weights_path) imgs, img_paths = utils.load_imgs(imgs_path) embs = get_embeddings(model, imgs) scipy.io.savemat(embs_path, mdict={'embs': embs, 'img_paths': img_paths}) print('done')
def __init__(self, config): self.reward = 0 self.terminal = True self.stop_step = config.stop_step self.reward_func = config.reward_func self.is_train = config.is_train self.count = 0 # count restoration step self.psnr, self.psnr_pre, self.psnr_init = 0., 0., 0. if self.is_train: # training data self.train_list = [ config.train_dir + file for file in os.listdir(config.train_dir) if file.endswith('.h5') ] self.train_cur = 0 self.train_max = len(self.train_list) f = h5py.File(self.train_list[self.train_cur], 'r') self.data = f['data'].value self.label = f['label'].value f.close() self.data_index = 0 self.data_len = len(self.data) # validation data f = h5py.File(config.val_dir + os.listdir(config.val_dir)[0], 'r') self.data_test = f['data'].value self.label_test = f['label'].value f.close() self.data_all = self.data_test self.label_all = self.label_test else: # test data self.test_batch = config.test_batch self.test_in = config.test_dir + config.dataset + '_in/' self.test_gt = config.test_dir + config.dataset + '_gt/' list_in = [ self.test_in + name for name in os.listdir(self.test_in) ] list_in.sort() list_gt = [ self.test_gt + name for name in os.listdir(self.test_gt) ] list_gt.sort() self.name_list = [ os.path.splitext(os.path.basename(file))[0] for file in list_in ] self.data_all, self.label_all = load_imgs(list_in, list_gt) self.test_total = len(list_in) self.test_cur = 0 # data reformat, because the data for tools training are in a different format self.data_all = data_reformat(self.data_all) self.label_all = data_reformat(self.label_all) self.data_test = self.data_all[ 0:min(self.test_batch, self.test_total), ...] self.label_test = self.label_all[ 0:min(self.test_batch, self.test_total), ...] # input PSNR self.base_psnr = 0. for k in range(len(self.data_all)): self.base_psnr += psnr_cal(self.data_all[k, ...], self.label_all[k, ...]) self.base_psnr /= len(self.data_all) # reward functions self.rewards = {'step_psnr_reward': step_psnr_reward} self.reward_function = self.rewards[self.reward_func] # build toolbox self.action_size = 12 + 1 toolbox_path = 'toolbox/' self.graphs = [] self.sessions = [] self.inputs = [] self.outputs = [] for idx in range(12): g = tf.Graph() with g.as_default(): # load graph saver = tf.train.import_meta_graph(toolbox_path + 'tool%02d' % (idx + 1) + '.meta') # input data input_data = g.get_tensor_by_name('Placeholder:0') self.inputs.append(input_data) # get the output output_data = g.get_tensor_by_name('sum:0') self.outputs.append(output_data) # save graph self.graphs.append(g) sess = tf.Session(graph=g, config=tf.ConfigProto(log_device_placement=True)) with g.as_default(): with sess.as_default(): saver.restore(sess, toolbox_path + 'tool%02d' % (idx + 1)) self.sessions.append(sess)
sigma=14, mode='reflect'), iaa.Affine(rotate=(-180, 180), mode='reflect'), ]) aug3 = augmenter(1, 256, 1, crop_before_augs=[ iaa.Fliplr(0.5), iaa.Flipud(0.5), iaa.ElasticTransformation(alpha=(100, 200), sigma=14, mode='nearest'), iaa.Affine(rotate=(-180, 180), mode='symmetric'), ]) imgs = load_imgs('./tmp_exp') for img in imgs: img1 = aug1.augment_images([img]) img2 = aug2.augment_images([img]) img3 = aug3.augment_images([img]) cv2.imshow('1', img1.reshape((256, 256, 1))) cv2.imshow('2', img2.reshape((256, 256, 1))) cv2.imshow('3', img3.reshape((256, 256, 1))) cv2.waitKey(0) ''' import re def human_sorted(iterable): convert = lambda text: int(text) if text.isdigit() else text alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', key)] return sorted(iterable, key = alphanum_key)