def save_objects_in_obj_name():
mt = MyTools()
f = "./obj.names"
objects = get_objects()
lines = ""
for obj in objects:
lines += obj + "\n"
mt.write_data_in_file(lines, f, "w")
def get_conf():
# Chemin courrant
abs_path = MyTools().get_absolute_path(__file__)
print("Chemin courrant", abs_path)
# Nom du script
name = os.path.basename(abs_path)
print("Nom de ce script:", name)
# Abs path de semaphore sans / à la fin
parts = abs_path.split("mon_semaphore")
print("parts", parts)
gl.root = os.path.join(parts[0], "mon_semaphore")
print("Path de semaphore:", gl.root)
def directory_rename():
mt = MyTools()
rep_num = 0
rep = "/media/data/3D/projets/darknet-letters/letters/game/textures/pngs"
sub_dirs = mt.get_all_sub_directories(rep)
# sub_dirs comprend pngs qui est le root
del sub_dirs[0]
for sb in sub_dirs:
dst = rep + "/font_" + str(rep_num)
print(sb, dst)
os.rename(sb, dst)
rep_num += 1
def save_test(root, resp, weight_list, gray, blur, learningrate):
mt = MyTools()
t = datetime.today().strftime("%Y-%m-%d %H:%M:%S")
a = "{} Date: {} TRAIN: {} TEST: {} Gray: {} Blur: {} Learningrate: {}\n"
line = a.format(format(round(resp, 2), '.2f'), t, TRAIN, TEST, gray, blur,
round(learningrate, 4))
print(line)
fichier = os.path.join(root, "hyperparameter_tuning.txt")
mt.write_data_in_file(line, fichier, "a")
name = str(round(resp, 2))
np.save(os.path.join(root, 'weights', 'weights_' + name + '.npy'),
weight_list)
def main():
"""Lancé une seule fois à la 1ère frame au début du jeu par main_once."""
print("Initialisation des scripts lancée un seule fois au début du jeu:")
# Le couteau suisse
gl.tools = MyTools()
# Récupération de la configuration
get_conf()
set_variable()
gl.nbr = -1
set_tempo()
get_sun_set()
# Numéro de toutes les lettres entre 0 et 399
get_obj_num()
# Carrés en dehors de la vue caméra
set_all_letters_position()
intro_init()
# Pour les mondoshawan
print("Initialisation du jeu terminée\n\n")
def __init__(self, size):
self.size = size
self.tools = MyTools()
# 10 polices possible seulement
self.colors = COLORS
self.color_num = 0
# Create pngs directory
self.tools.create_directory("./pngs")
# Dict des dossiers avec ttf
self.ttf_list = self.get_ttfs()
# Création des sous dossiers dans ./pngs
self.create_sub_directories()
def __init__(self, root, size):
self.root = root # soit ..../semaphore
self.size = int(size)
# Mes outils personnels
self.tools = MyTools()
# Renommage de training_shot en training_shot_copy
self.rename_training_shot()
# Re-création des dossiers
self.create_training_shot_dir()
self.create_sub_folders()
# Liste des images
self.shot_list = self.get_shot_list()
def test(dossier, essai):
"""
best = 41000
last = 43000
final = 42000
"""
mt = MyTools()
w_dir = "/media/data/projets/darknet-letters/letters/darknet/data_22/backup/"
w_list = mt.get_all_files_list(w_dir, ".weights")
#print("\n\nTous les fichiers de poids:", w_list)
for w in w_list:
# Pas le dossier principal
if w:
print("\n\nFichier de poids en cours:", w, "\n\n")
if w != w_dir:
play_letters(dossier, essai, test=1, weights=w)
def __init__(self):
self.tools = MyTools()
# Liste des images du répertoire
root = "/media/data/3D/projets/darknet-letters/letters/ttf_to_png"
imgs = self.tools.get_all_files_list(root + "/pngs", ".png")
# [... , CognacRum ,Z.png]
for img in imgs:
if "a.png" in img or "A.png" in img:
name_list = img.split("/")
name = name_list[-2] + "_" + name_list[-1]
file_name = root + "/fonts_chooser/" + name
print(file_name)
image = cv2.imread(img, cv2.IMREAD_UNCHANGED)
cv2.imwrite(file_name, image)
def get_conf():
"""Récupère la configuration depuis le fichier *.ini."""
gl.tools = MyTools()
gl.letters_dir = str(LETTERS_DIR.resolve())
# Dossier *.ini
ini_file = gl.letters_dir + "/letters.ini"
gl.ma_conf = MyConfig(ini_file, verbose=0)
gl.conf = gl.ma_conf.conf
def __init__(self, size, video, number=1000):
"""
letters = {'a': image de a,
' ': image de ' ',
etc ...}
"""
self.size = size
self.number = number
self.tools = MyTools()
self.create_directories()
self.letters = self.get_letters_images()
self.numero_lettre = 0
self.capture = cv2.VideoCapture(video)
self.width = int(self.capture.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
print("Taille Video:", self.width, self.height)
self.get_shots()
def __init__(self, midi_file, FPS, volume=""):
"""Un seul fichier midi
FPS de 10 à 1000, 50 ou 100 est bien
Plus le FPS est élevé, plus le temps de calcul est long !
"""
print("\n\nAnalyse de", midi_file.split('/')[-1], "\n")
self.midi_file = midi_file
self.FPS = FPS
self.volume = volume
self.end_time = 0
self.instruments = None
self.instruments = []
self.partitions = []
self.mytools = MyTools()
# Pour gérer les threads dans blender
self.end = 0
def __init__(self):
"""self.conf est le dict de la config définie dans global.ini"""
path = MyTools().get_absolute_path(__file__)
print("Nom de ce script:", os.path.basename(path)) # semaphore.py
self.root = os.path.split(path)[0]
print("Path du projet:",
self.root) #'/media/data/3D/projets/semaphore'
ini_file = os.path.join(self.root, "global.ini")
super().__init__(ini_file)
def __init__(self):
self.mt = MyTools()
self.blur_mini = CONF["letters_shot_jpg"]["blur_mini"]
self.blur_maxi = CONF["letters_shot_jpg"]["blur_maxi"]
self.size = CONF["letters_shot_jpg"]["shot_size"]
# Dossiers
self.shot = shot_dir
print("Dossier shot:", self.shot)
self.create_shot_jpg()
self.create_sub_directories()
# Images png
self.all_png_files = self.mt.get_all_files_list(self.shot, '.png')
print("Nombre de fichiers à convertir:", len(self.all_png_files))
if len(self.all_png_files) == 0:
print("\n\nPas d'images à convertir")
print("Créer les images avant !")
os._exit(0)
# Exécution du script flou puis save
self.save_to_jpg()
def get_conf():
"""Récupère la configuration depuis le fichier *.ini."""
# Chemin courrant
abs_path = MyTools().get_absolute_path(__file__)
print("Chemin courrant", abs_path)
# Nom du script
name = os.path.basename(abs_path)
print("Nom de ce script:", name)
# Abs path de semaphore sans / à la fin
parts = abs_path.split("semaphore")
gl.root = os.path.join(parts[0], "semaphore")
print("Path de semaphore:", gl.root)
# Dossier *.ini
ini_file = os.path.join(gl.root, "global.ini")
gl.ma_conf = MyConfig(ini_file)
gl.conf = gl.ma_conf.conf
print("\nConfiguration du jeu semaphore:")
print(gl.conf, "\n")
def __init__(self, root, size, blur, imshow=1):
""" root = dossier semaphore
size = taille des images pour l'ia
blur = 0 à 10 pour flouter les images pour l'ia
imshow = 0 ou 1 pour affichage d'image ou non pendant l'exécution
"""
self.root = root # soit ..../semaphore
self.size = int(size)
self.size = max(20, self.size)
self.size = min(800, self.size)
self.blur = blur
self.imshow = imshow
# Mes outils personnels
self.tools = MyTools()
# Le terrain de jeu
self.create_training_shot_resized_dir()
# Liste
self.shot_list = self.get_shot_list()
self.create_sub_folders()
def create_directories():
"""
Création de n dossiers
un fichier = ./semaphore/shot/shot_0/shot_a_0.png
"""
# Dossier d'enregistrement des images
gl.shot_directory = os.path.join(gl.root, 'training_shot')
print("Dossier des shots:", gl.shot_directory)
# Si le dossier n'existe pas, je le crée
mt = MyTools()
mt.create_directory(gl.shot_directory)
# Nombre de dossiers nécessaires
n = int(gl.nombre_shot_total / gl.nombre_de_fichiers_par_dossier) + 1
for i in range(n):
directory = os.path.join(gl.shot_directory, 'shot_' + str(i).zfill(3))
mt.create_directory(directory)
class CreateShot:
def __init__(self, size, video, number=1000):
"""
letters = {'a': image de a,
' ': image de ' ',
etc ...}
"""
self.size = size
self.number = number
self.tools = MyTools()
self.create_directories()
self.letters = self.get_letters_images()
self.numero_lettre = 0
self.capture = cv2.VideoCapture(video)
self.width = int(self.capture.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
print("Taille Video:", self.width, self.height)
self.get_shots()
def create_directories(self):
"""Un dossier root=shot, un sous dossier par lettre"""
self.tools.create_directory("./shot")
for l in LETTRES:
if l == " ":
l = "space"
self.tools.create_directory("./shot/shot_" + l)
def get_letters_files(self):
letters_files = self.tools.get_all_files_list("lettre_epaisse_alpha",
".png")
print("Nombre de letters =", len(letters_files))
return letters_files
def get_letters_images(self):
"""Récupère toutes les images de lettres"""
letters = {}
for l_file in self.get_letters_files():
# lettre/shot_10_j.png
l = l_file[:-4][-1]
img = cv2.imread(l_file, -1)
img = delete_gray(img)
letters[l] = img
return letters
def frame_resize(self, frame):
"""Pour 1024: resize puis coupe des 2 cotés de 398
pour 416: 1280x720 devient 739x416
"""
# Largeur
a = int(self.width * self.size / self.height)
# Hauteur
b = self.size
# Resize
frame = cv2.resize(frame, (a, b), interpolation=cv2.INTER_AREA)
# Coupe
x = int((a - b) / 2)
y = 0
w, h = self.size, self.size
frame = frame[y:y + h, x:x + w]
return frame
def aspect_change(self, lettre):
"""Couleur, flou, rotation
lettre est l'image de la lettre
"""
bg_color = lettre[0][0]
R = random.randint(0, 100)
G = random.randint(0, 50)
B = random.randint(100, 255)
lettre[np.all(lettre == [0, 0, 0, 255], axis=2)] = [R, G, B, 255]
mask = np.all(lettre == bg_color, axis=2)
lettre[mask] = [0, 0, 0, 0]
# Rotation
some = random.randint(-3, 3)
lettre = rotateImage(lettre, some)
# Flou de 0 à 4
flou = random.randint(0, 4)
if flou != 0:
lettre = cv2.blur(lettre, (flou, flou))
return lettre
def lettre_image_change(self, lettre):
"""Adapte une lettre, calcule taille, position, flou, couleur
lettre est l'image de la lettre
"""
# Modification de l'aspect
lettre = self.aspect_change(lettre)
# Variation sur la taille du sémaphore
semaphore_mini = int(self.size / 7)
w, h = lettre.shape[1], lettre.shape[0]
# Set de la hauteur, puis largeur
y_size = random.randint(semaphore_mini, int(self.size * 0.8))
x_size = int(w * y_size / h)
# Maxi de taille de lettre < self.size
y_size = min(y_size, self.size)
x_size = min(x_size, self.size)
lettre = cv2.resize(lettre, (x_size, y_size),
interpolation=cv2.INTER_CUBIC)
# Position posible
x = random.randint(0, self.size - x_size)
y = random.randint(0, self.size - y_size)
return lettre, x_size, y_size, x, y
def overlay(self, frame):
"""Trouve une lettre, supperpose à la frame"""
# Lecture des lettres de l'alphabet en boucle
l = LETTRES[self.numero_lettre]
self.numero_lettre += 1
if self.numero_lettre == 27:
self.numero_lettre = 0
# lettre est l'image de lettre
lettre = self.letters[l]
# Adaptation
lettre, x_size, y_size, x, y = self.lettre_image_change(lettre)
# Overlay
img = over_transparent(frame, lettre, x, y)
return img, l, x_size, y_size, x, y
def save(self, img, lettre, x_size, y_size, x, y, n):
"""Enregistrement dans le dossier ./shot/shot_a/ de
shot_0_a.jpg et shot_0_a.txt
class position(x y) taille(x y)
x, y position du coin haut gauche
s = taille de la lettre
"""
# Get indice avant modif liste
indice = LETTRES.index(lettre)
# pour avoir dossier clair
if lettre == " ":
lettre = "space"
# Avec sous dossiers
fichier = "./shot/shot_" + lettre + "/shot_" + str(n) + "_" + lettre
# Enregistrement de l'image
cv2.imwrite(fichier + ".jpg", img)
# Enregistrement des datas
# Taille relative de l'image lettre
tx = x_size / self.size
ty = y_size / self.size
# Origine = top left
xc = (x + (x_size / 2)) / self.size
yc = (y + (y_size / 2)) / self.size
# class-position du centre-taille
data = (str(indice) + " " + str(xc) + " " + str(yc) + " " + str(tx) +
" " + str(ty))
self.tools.write_data_in_file(data, fichier + ".txt", "w")
def get_shots(self):
n, m = 0, 0
self.loop = 1
while self.loop:
ret, frame = self.capture.read()
if ret:
# pour enregistrer 1 frame sur 10 et varier les fonds
if n % 10 == 0:
frame = self.frame_resize(frame)
# Overlay d'une lettre
img, l, x_size, y_size, x, y = self.overlay(frame)
print("Shot numéro", m, "Lettre", l)
# Enregistrement de l'image et du fichier txt
self.save(img, l, x_size, y_size, x, y, m)
m += 1
cv2.imshow("image", img)
# Jusqu'à number
n += 1
if m == self.number:
self.loop = 0
# Echap et attente
k = cv2.waitKey(10)
if k == 27:
self.loop = 0
else:
# Reset si la video est terminée
self.capture = cv2.VideoCapture(video)
print("Nombre d'images crées:", m)
cv2.destroyAllWindows()
import os, sys
import random
from pymultilame import MyTools
# Import du dossier parent soit letters
# Pas d'import possible direct du dossier parent
# ValueError: attempted relative import beyond top-level package
sys.path.append("..")
from letters_path import LettersPath
lp = LettersPath()
letters_dir = lp.letters_dir
CONF = lp.conf
mt = MyTools()
# Dossier des images et txt
SHOT_JPG = lp.shot_jpg_dir
# liste de toutes les images
files = mt.get_all_files_list(SHOT_JPG, '.jpg')
# Rebat les cartes pour prendre les fichiers au hazard dans les sous-dossiers
random.shuffle(files)
nb = len(files)
print("Nombre de fichiers", nb)
if nb == 0:
print("\n\nErreur:")
print("Définir les chemins de shot_jpg dans letters.ini\n\n")
os._exit(0)
class ResizeTrainingShot:
def __init__(self, root, size):
self.root = root # soit ..../semaphore
self.size = int(size)
# Mes outils personnels
self.tools = MyTools()
# Renommage de training_shot en training_shot_copy
self.rename_training_shot()
# Re-création des dossiers
self.create_training_shot_dir()
self.create_sub_folders()
# Liste des images
self.shot_list = self.get_shot_list()
def rename_training_shot(self):
ori = os.path.join(self.root, "training_shot")
dest = os.path.join(self.root, "training_shot_copy")
os.rename(ori, dest)
def create_training_shot_dir(self):
directory = os.path.join(self.root, "training_shot")
print("Dossier training_shot:", directory)
self.tools.create_directory(directory)
def create_sub_folders(self):
"""Création de n dossiers shot_000"""
# Nombre de dossiers nécessaires
d = os.path.join(self.root, "training_shot_copy")
n = len(self.tools.get_all_sub_directories(d)) - 1
print("Nombre de sous répertoires", n)
for i in range(n):
directory = os.path.join(self.root, 'training_shot',
'shot_' + str(i).zfill(3))
self.tools.create_directory(directory)
print("Sous répertoires créés")
def get_shot_list(self):
"""Liste des images"""
# Liste
shot = os.path.join(self.root, "training_shot_copy")
shot_list = self.tools.get_all_files_list(shot, ".png")
print("Dossier des images NB:", shot)
print("Nombre d'images:", len(shot_list))
return shot_list
def change_resolution(self, img, x, y):
"""Une image peut-être ratée"""
try:
res = cv2.resize(img, (x, y), interpolation=cv2.INTER_AREA)
except:
res = np.zeros([self.size, self.size, 1], dtype=np.uint8)
return res
def get_new_name(self, shot):
return shot.replace("/training_shot_copy/", "/training_shot/")
def create_training_shot_resized_dir(self):
directory = os.path.join(self.root, "training_shot_resized")
print("Dossier training_shot_resized:", directory)
self.tools.create_directory(directory)
def batch(self):
"""Lecture, resize, save"""
i = 0
# Pour chaque image
for shot in self.shot_list:
# Lecture
img = cv2.imread(shot, 0)
# Resize
img_out = self.change_resolution(img, self.size, self.size)
i += 1
# Save
new_shot = self.get_new_name(shot)
print(new_shot)
cv2.imwrite(new_shot, img_out)
# Import du dossier parent soit letters
# Pas d'import possible direct du dossier parent
# ValueError: attempted relative import beyond top-level package
sys.path.append("..")
from letters_path import LettersPath
lp = LettersPath()
letters_dir = lp.letters_dir
CONF = lp.conf
shot_control_dir = lp.shot_control_dir
# Définir le chemin des shot à contrôler dans letters.ini
shot_jpg_dir = lp.shot_jpg_dir
tools = MyTools()
def cvDrawBoxes(img, coords):
"""Dessine le rectangle avec centre(cx, cy) et taille w et h"""
# taille des images
size = img.shape[0]
# Rectangle
cx = float(coords[1]) * size
cy = float(coords[2]) * size
w = float(coords[3]) * size
h = float(coords[4]) * size
xmin = int(cx - w / 2)
#
# This file is part of pymultilame.
# pymultilame is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# pymultilame is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with pymultilame. If not, see <https://www.gnu.org/licenses/>.
#######################################################################
"""
Convertit le README.md en README.dokuwiki pour la page du wiki.
"""
from pymultilame import MyTools
mt = MyTools()
command = [
'pandoc', 'README.md', '-f', 'markdown', '-t', 'dokuwiki', '-s', '-o',
'README.dokuwiki'
]
mt.run_command_system(command)
class GetVideoWithSemaphore:
def __init__(self, video_in, video_out, lenght, every):
""" """
self.video_in = video_in
self.video_out = video_out
self.lenght = lenght
self.every = every * 24
# [[y_size, x_pos, y_pos]]
self.size_pos_list = []
# mes outils perso: pymultilame
self.tools = MyTools()
self.letters = self.get_letters_images()
self.numero_lettre = 0
# Video d'entrèe
self.video_in = cv2.VideoCapture(video_in)
self.width = int(self.video_in.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.video_in.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.FPS = self.video_in.get(cv2.CAP_PROP_FPS)
print("Video d'entrèe:", self.width, self.height, self.FPS)
fourcc = cv2.VideoWriter_fourcc(*'MPEG')
self.video = cv2.VideoWriter(self.video_out, fourcc, float(self.FPS),
(self.width, self.height))
# Lance la création de la video
self.get_semaphore_video()
def get_letters_files(self):
letters_files = self.tools.get_all_files_list("lettre_epaisse_alpha",
".png")
print("Nombre de letters =", len(letters_files))
return letters_files
def get_letters_images(self):
"""Récupère toutes les images de lettres"""
letters = {}
for l_file in self.get_letters_files():
# lettre/shot_10_j.png
l = l_file[:-4][-1]
letters[l] = cv2.imread(l_file, -1)
return letters
def overlay(self, frame, lettre_img_list, lettre_list, change):
""" Conservation dans self.size_pos_list = [[y_size, x_pos, y_pos]]
lettre_img_list: liste des images des lettres [image_de_a, image_de_f, ...]
lettre_list: liste des lettres ['a', 'f', ...]
change = changement de lettre, soit affichage des lettres en cours
"""
for i in range(len(lettre_list)):
# changement seulement à every
if change == 1:
# Plage de taille possible
h_mini_semaphore = int(self.height / 10)
h_maxi_semaphore = int(self.height / 1.2)
# Choix
y_size = random.randint(h_mini_semaphore, h_maxi_semaphore)
# x découle de y
x_size = int(lettre_img_list[i].shape[1] * \
y_size/lettre_img_list[i].shape[0])
# Application de la taille à la lettre en cours
img = cv2.resize(lettre_img_list[i], (x_size, y_size),
interpolation=cv2.INTER_CUBIC)
# Position
x_pos = random.randint(50, self.width - x_size - 50)
y_pos = random.randint(0, self.height - y_size)
# Storage
self.size_pos_list.append([y_size, x_pos, y_pos])
print("Ajout de", [y_size, x_pos, y_pos])
else: # change == 0
y_size = self.size_pos_list[i][0]
x_size = int(lettre_img_list[i].shape[1] * \
y_size/lettre_img_list[i].shape[0])
x_pos = self.size_pos_list[i][1]
y_pos = self.size_pos_list[i][2]
img = cv2.resize(lettre_img_list[i], (x_size, y_size),
interpolation=cv2.INTER_CUBIC)
# Modification de l'aspect de la lettre
img = aspect_change(img)
# Overlay de lettre_img déjà retaillée à position x, y
frame = over_transparent(frame, img, x_pos, y_pos)
return frame
def add_lettre(self, frame, lettre_list):
k = 0
for l in lettre_list:
if l == " ":
l = "space"
# Overlay du caractère l
font = cv2.FONT_HERSHEY_SIMPLEX
frame = cv2.putText(frame, l, (10, int(self.height * (0.95 - k))),
font, 1, (255, 255, 255), 2, cv2.LINE_AA)
k += 0.06
return frame
def get_lettre_list(self):
"""Retourne une liste d'image de lettres et une liste de ces lettres"""
# Get some lettres au hasard
lettre_list = []
lettre_img_list = []
# Get n lettres
n = random.randint(1, 3)
for i in range(n):
k = random.randint(0, 26)
lettre_list.append(list(self.letters.keys())[k])
print("\nListe des lettre:", lettre_list, "\n")
for u in range(len(lettre_list)):
lettre_img_list.append(self.letters[lettre_list[u]])
return lettre_img_list, lettre_list
def get_semaphore_video(self):
"""Une lettre ajoutée et changée toutes les every secondes"""
how_many = 0
letter_duration = 0
loop = 1
change = 1
# Initialisation
lettre_img_list, lettre_list = self.get_lettre_list()
while loop:
ret, frame = self.video_in.read()
letter_duration += 1
# Changement de lettres
if letter_duration == self.every:
lettre_img_list, lettre_list = self.get_lettre_list()
change = 1
# Reset
self.size_pos_list = []
letter_duration = 0
# Overlay des images de lettres
frame = self.overlay(frame, lettre_img_list, lettre_list, change)
# Overlay des textes de lettres
frame = self.add_lettre(frame, lettre_list)
# On reste sur les mêmes lettres pendant every
change = 0
cv2.imshow('Out', frame)
self.video.write(frame)
# Jusqu'à la durée demandée
how_many += 1
if how_many == self.FPS * self.lenght:
loop = 0
# Echap et attente
k = cv2.waitKey(33)
if k == 27:
loop = 0
self.video.release()
cv2.destroyAllWindows()
def __init__(self, images_directory, essai, save, test=0, weights=""):
"""
essai = numéro del'eaasi dans ini
save = sauvegarde des notes en json
test = bidouilles pour passer une série de weights
"""
# Mes outils
self.mt = MyTools()
self.lp = LettersPath()
self.CONF = self.lp.conf
self.essai = essai
self.save = save
self.test = test
self.weights = weights
if self.weights:
print("Fichier de poids utilisé:", self.weights)
self.get_weights_file_indice()
if self.weights:
self.create_test_subdir()
# Paramètres de la conf
# Avec ou sans GPU
self.gpu = self.CONF['play_letters']['gpu']
# Résolution de l'écran ou du VP: x, y
self.screen = self.CONF['play_letters']['screen']
# Boucle opencv
self.loop = 1
self.fps = 0
# Récup des images
self.images_directory = images_directory
self.shot_list = self.get_sorted_shot_list()
self.all_shot = self.get_all_shot()
# nom du morceau
self.filename = self.images_directory.split("/")[-1]
# Initialisation de la détection
self.set_darknet()
# Paramètres de détections
self.thresh = int(self.CONF['play_letters']['thresh'])
self.hier_thresh = int(self.CONF['play_letters']['hier_thresh'])
self.nms = int(self.CONF['play_letters']['nms'])
# Windows
self.create_windows()
# Trackbars
self.create_trackbar()
self.set_init_tackbar_position()
# Midi
self.fonts = self.CONF['music_and_letters']['fonts']
self.instruments = []
self.get_instruments()
self.notes_en_cours = []
self.players = {}
self.set_players()
self.all_notes = []
class GetVideoWithSemaphore:
def __init__(self, video_in, video_out, lenght, every):
""" """
self.video_in = video_in
self.video_out = video_out
self.lenght = lenght
self.every = every * 24
self.y_fix = 0
self.x_pos = 0
self.y_pos = 0
# mes outils perso: pymultilame
self.tools = MyTools()
self.letters = self.get_letters_images()
self.numero_lettre = 0
# Video d'entrèe
self.video_in = cv2.VideoCapture(video_in)
self.width = int(self.video_in.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.video_in.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.FPS = self.video_in.get(cv2.CAP_PROP_FPS)
print("Video d'entrèe:", self.width, self.height, self.FPS)
fourcc = cv2.VideoWriter_fourcc(*'MPEG')
self.video = cv2.VideoWriter(self.video_out, fourcc, float(self.FPS),
(self.width, self.height))
# Lance la création de la video
self.get_semaphore_video()
def get_letters_files(self):
letters_files = self.tools.get_all_files_list("lettre", ".png")
print("Nombre de letters =", len(letters_files))
return letters_files
def get_letters_images(self):
"""Récupère toutes les images de lettres"""
letters = {}
for l_file in self.get_letters_files():
# lettre/shot_10_j.png
l = l_file[:-4][-1]
letters[l] = cv2.imread(l_file, -1)
return letters
def overlay(self, frame, lettre_img, lettre, change):
"""
lettre 320x320 variation 100 à 800
frame 1024x1024
position
exempe 624: 1024-624 = 400
"""
# Variation sur la taille du sémaphore
semaphore_mini = int(self.height / 7)
w, h = lettre_img.shape[1], lettre_img.shape[0]
# Set de la hauteur, puis largeur
if change == 1: # changement seulement à every
y_size = random.randint(semaphore_mini, int(self.height * 0.8))
self.y_fix = y_size
else:
y_size = self.y_fix
x_size = int(w * y_size / h)
# Maxi de taille de lettre_img < self.height
y_size = min(y_size, self.height)
x_size = min(x_size, self.height)
lettre_img = cv2.resize(lettre_img, (x_size, y_size),
interpolation=cv2.INTER_CUBIC)
# Position posible
if change == 1: # changement seulement à every
x = random.randint(0, self.height - x_size)
self.x_pos = x
y = random.randint(0, self.height - y_size)
self.y_pos = y
else:
x = self.x_pos
y = self.y_pos
img = over_transparent(frame, lettre_img, x, y)
# Overlay du caractère l
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img, lettre, (10, int(self.height * 0.8)), font, 4,
(255, 255, 255), 2, cv2.LINE_AA)
return img
def get_lettre(self):
# Lecture des lettres de l'alphabet en boucle
l = list(self.letters.keys())[self.numero_lettre]
print("Lettre en cours", l, self.numero_lettre)
self.numero_lettre += 1
if self.numero_lettre == 27:
self.numero_lettre = 0
lettre_img = self.letters[l]
return lettre_img, l
def get_semaphore_video(self):
"""Une lettre ajoutée et changée toutes les every secondes"""
how_many = 0
letter_duration = 0
loop = 1
change = 1
# Initialisation
lettre_img, lettre = self.get_lettre()
while loop:
ret, frame = self.video_in.read()
letter_duration += 1
if letter_duration == self.every:
# lettre_img est l'image de la lettre lettre
lettre_img, lettre = self.get_lettre()
change = 1
letter_duration = 0
# Overlay d'une lettre
frame = self.overlay(frame, lettre_img, lettre, change)
change = 0
cv2.imshow('Out', frame)
self.video.write(frame)
# Jusqu'à la durée demandée
how_many += 1
if how_many == self.FPS * self.lenght:
loop = 0
# Echap et attente
k = cv2.waitKey(2)
if k == 27:
loop = 0
self.video.release()
cv2.destroyAllWindows()
from random import randint
from pymultilame import MyTools
# Import du dossier parent soit letters
# Pas d'import possible direct du dossier parent
# ValueError: attempted relative import beyond top-level package
sys.path.append("..")
from letters_path import LettersPath
lp = LettersPath()
letters_dir = lp.letters_dir
CONF = lp.conf
# Le couteau
tools = MyTools()
# Nombre de shot à réaliser
nbr = CONF["letters_shot"]["nombre_shot_total"]
loop = int(nbr / 115) + 1
print("Nombre de boucle à réaliser", loop)
json_dict = {"partitions": [], "instruments": []}
# Définition des instruments
for i in range(10):
instr = [[0, 0], "false", " "]
json_dict["instruments"].append(instr)
# Liste des possibles
# 19 valeurs * maj et min * 10 = 380 objets
class ResizeBlur:
def __init__(self, root, size, blur, imshow=1):
""" root = dossier semaphore
size = taille des images pour l'ia
blur = 0 à 10 pour flouter les images pour l'ia
imshow = 0 ou 1 pour affichage d'image ou non pendant l'exécution
"""
self.root = root # soit ..../semaphore
self.size = int(size)
self.size = max(20, self.size)
self.size = min(800, self.size)
self.blur = blur
self.imshow = imshow
# Mes outils personnels
self.tools = MyTools()
# Le terrain de jeu
self.create_training_shot_resized_dir()
# Liste
self.shot_list = self.get_shot_list()
self.create_sub_folders()
def create_training_shot_resized_dir(self):
directory = os.path.join(self.root, "training_shot_resized")
print("Dossier training_shot_resized:", directory)
self.tools.create_directory(directory)
def create_sub_folders(self):
"""Création de n dossiers shot_000"""
# Nombre de dossiers nécessaires
d = os.path.join(self.root, "training_shot")
n = len(self.tools.get_all_sub_directories(d)) - 1
print("Nombre de sous répertoires", n)
for i in range(n):
directory = os.path.join(self.root, 'training_shot_resized',
'shot_' + str(i).zfill(3))
self.tools.create_directory(directory)
def get_new_name(self, shot):
""" de
/media/data/3D/projets/semaphore/training_shot/shot_000/shot_0_a.png
à
/media/data/3D/projets/semaphore/training_shot_resized/shot_000/shot_0_a.png
j'ai
/media/data/3D/projets/semaphore/training_shot_resized/shot_000/shot_3921_h.png
"""
t = shot.partition("training_shot")
# t = ('/media/data/3D/projets/semaphore/', 'training_shot',
# '/shot_000/shot_1054_s.png')
name = os.path.join(self.root, "training_shot_resized", t[2][1:])
return name
def change_resolution(self, img, x, y):
"""Une image peut-être ratée"""
try:
res = cv2.resize(img, (x, y), interpolation=cv2.INTER_AREA)
except:
res = np.zeros([self.size, self.size, 1], dtype=np.uint8)
return res
def apply_blur(self, img, k):
"""TODO: Utiliser GaussianBlur
img = cv2.GaussianBlur(img, (5, 5), 0)
"""
if self.blur:
img = cv2.blur(img, (k, k))
return img
def random_noise(self, img):
"""Entre 0 et 20 pixels au hasard"""
nb = random.randint(0, 10)
for i in range(nb):
x = random.randint(0, 39)
y = random.randint(0, 39)
img[x][y] = 1
return img
def some_dirty(self, img):
"""0 à 3 paquets de 4 pixels
0 1 0
1 1 1
0 1 0
"""
nb = random.randint(0, 2)
for i in range(nb):
x = random.randint(0, 34)
y = random.randint(0, 34)
# 1ère ligne
a = x + 1
b = y + 0
img[a][b] = 1
# 2ème ligne
for u in range(3):
a = x + u
b = y + 1
img[a][b] = 1
# 3ème ligne
a = x + 1
b = y + 2
img[a][b] = 1
return img
def batch(self):
"""Liste des images, lecture, conversion, save"""
i = 0
if self.imshow:
cv2.namedWindow('Image In')
cv2.namedWindow('Image Out')
# Pour chaque image
for shot in self.shot_list:
# Lecture
img = cv2.imread(shot, 0)
# ResizeBlur
img_out = self.change_resolution(img, self.size, self.size)
# Flou
img_out = self.apply_blur(img_out, self.blur)
# Noise
# L'ajout de bruit est appris par le réseau et va dégrader la
# reconnaissance, mais Jo dit que non, ça dépend de ???
# #img_out = self.random_noise(img_out)
# #img_out = self.some_dirty(img_out)
# ## Affichage
if self.imshow:
if i % 500 == 0:
#print(i)
imgB = self.change_resolution(img_out, 600, 600)
cv2.imshow('Image In', img)
cv2.imshow('Image Out', imgB)
cv2.waitKey(1)
i += 1
# Save
new_shot = self.get_new_name(shot)
cv2.imwrite(new_shot, img_out)
cv2.destroyAllWindows()
def get_shot_list(self):
"""Liste des images"""
# Liste
shot = os.path.join(self.root, "training_shot")
shot_list = self.tools.get_all_files_list(shot, ".png")
print("Dossier des images NB:", shot)
print("Nombre d'images:", len(shot_list))
return shot_list
class BlurAndConvert:
def __init__(self):
self.mt = MyTools()
self.blur_mini = CONF["letters_shot_jpg"]["blur_mini"]
self.blur_maxi = CONF["letters_shot_jpg"]["blur_maxi"]
self.size = CONF["letters_shot_jpg"]["shot_size"]
# Dossiers
self.shot = shot_dir
print("Dossier shot:", self.shot)
self.create_shot_jpg()
self.create_sub_directories()
# Images png
self.all_png_files = self.mt.get_all_files_list(self.shot, '.png')
print("Nombre de fichiers à convertir:", len(self.all_png_files))
if len(self.all_png_files) == 0:
print("\n\nPas d'images à convertir")
print("Créer les images avant !")
os._exit(0)
# Exécution du script flou puis save
self.save_to_jpg()
def create_shot_jpg(self):
self.shot_jpg = shot_jpg
print("Dossier shot_jpg:", self.shot_jpg)
# Si le dossier n'existe pas, je le crée
self.mt.create_directory(self.shot_jpg)
def create_sub_directories(self):
"""Création de 100 dossiers."""
# Répartition dans 100 sous dossiers
for l in range(100):
directory = os.path.join(self.shot_jpg, str(l))
self.mt.create_directory(directory)
def blur(self, img):
# Flou
k = random.randint(self.blur_mini, self.blur_maxi)
if k != 0:
img = cv2.blur(img, (k, k))
return img
def save_to_jpg(self):
n = 0
for png in self.all_png_files:
if n % 100 == 0 and n != 0:
a = len(self.all_png_files)
print("Nombre de fichiers convertis:", n, "sur", a)
n += 1
# Lecture de png
img = cv2.imread(png)
# Flou
img = self.blur(img)
# Retaillage avec size de letters.ini
img = cv2.resize(img, (self.size, self.size), interpolation=cv2.INTER_AREA)
# On travaille avec Path
png_path = Path(png)
jpg_path = self.get_jpg_name(png_path) # PosixPath
# Ecriture de l'image jpg, cv2 prend seulement path en str
cv2.imwrite(str(jpg_path), img,
[int(cv2.IMWRITE_JPEG_QUALITY),
100])
# Copie du fichier txt de png dans jpg
txt, dst = self.get_txt_dst(png_path, jpg_path)
copyfile(txt, dst)
# On prend son temps
sleep(0.01)
print("Nombre de fichiers convertis:", n)
def get_jpg_name(self, png_path):
""" png = str
png = str(self.shot) + /25/shot_4126.png = str
jpg = str(self.shot_jpg) + /25/shot_4126.jpg = str
"""
# Soustraction du chemin de shot_dir
a = str(png_path).replace(str(shot_dir), "")
# Ajout du chemin de jpg_dir
b = Path(str(shot_jpg) + a)
# Changement de l'extension
jpg_path = b.with_suffix(".jpg")
return jpg_path
def get_txt_dst(self, png_path, jpg_path):
txt_path = png_path.with_suffix(".txt")
dst_path = jpg_path.with_suffix(".txt")
return txt_path, dst_path
class AnalyseMidi:
"""Analyse le fichier midi,
trouve le nombre et le nom des instruments.
Retourne la liste des notes sur une time lapse de chaque instrument.
save_midi_json enregistre le midi en json
partitions = liste des partitions
instruments = liste des instruments soit objet avec .program et .name
L'enregistrement des json avec chemins absolus ne marche que pour letters
Sous répertoires et sous sous répertoires possible dans /music
"""
def __init__(self, midi_file, FPS, volume=""):
"""Un seul fichier midi
FPS de 10 à 1000, 50 ou 100 est bien
Plus le FPS est élevé, plus le temps de calcul est long !
"""
print("\n\nAnalyse de", midi_file.split('/')[-1], "\n")
self.midi_file = midi_file
self.FPS = FPS
self.volume = volume
self.end_time = 0
self.instruments = None
self.instruments = []
self.partitions = []
self.mytools = MyTools()
# Pour gérer les threads dans blender
self.end = 0
def get_instruments(self):
"""instruments =
[Instrument(program=71, is_drum=False, name="Grand Piano"), ...]
"""
# Récupération des datas avec pretty_midi
midi_pretty_format = my_pretty_midi.PrettyMIDI(self.midi_file)
# Supprime les notes avec fin avant le début !
midi_pretty_format.remove_invalid_notes()
# Time de fin, instruments du fichier
self.end_time = midi_pretty_format.get_end_time()
self.instruments_without_drums = midi_pretty_format.instruments
# Correction des intruments pour avoir le program des drums
self.get_instruments_with_drums()
return self.instruments
def get_instruments_with_drums(self):
""""De:
[Instrument(program=25, is_drum=False, name="Bass"),
Instrument(program=0, is_drum=True, name="Drums"),
Instrument(program=0, is_drum=True, name="Drums2")]
pour une liste de tuple:
[((0, 25), False, "Bass"),
((0, 116), True, "Drums"),
((8, 115), True, "Drums2")]
Pour le dict du json
"instruments": [[(0, 25), false], [(0, 116), true], [(8, 116), true]]}
"""
for instrument in self.instruments_without_drums:
program = instrument.program
is_drum = instrument.is_drum
name = instrument.name
if is_drum:
bank, bank_nbr = self.get_drum_program()
else:
bank = 0
bank_nbr = int(program)
self.instruments.append(((bank, bank_nbr), is_drum, name))
def get_drum_program(self):
""" Cas possible:
0 114 Steel Drums
0 115 Woodblock
0 116 Taiko Drum
0 117 Melodic Tom
0 118 Synth Drum
0 119 Reverse Cymbal
8 116 Concert Bass Drum
8 117 Melo Tom 2
8 118 808 Tom
"""
drums = [(0, 112),
(0, 113),
(0, 114),
(0, 115),
(0, 116),
(0, 117),
(0, 118),
(0, 119),
(8, 116),
(8, 117),
(8, 118)]
c = choice(drums)
return c[0], c[1]
def get_partitions_and_instruments(self):
"""Fait les étapes pour tous les instruments,
retourne les instruments et leurs partitions.
"""
# Si fichier midi anormal
try:
self.get_instruments()
except:
print("Instruments non récupérable dans le fichier midi\n")
self.instruments_without_drums = []
# Si nombre d'instrument > 10 pour IA
if len(self.instruments) > 10:
return None, None
for instrument in self.instruments_without_drums:
if instrument.is_drum:
drum = "Drum"
else:
drum = ""
print(" Analyse de l'instrument: {:>2} {:>6} Name: {:>24}".\
format(instrument.program, drum, instrument.name))
# Array de 128 x nombre de frames
instrument_roll = self.get_instrument_roll(instrument)
# Conversion dans une liste de listes python
partition = self.get_partition(instrument_roll, instrument)
self.partitions.append(partition)
print()
return self.partitions, self.instruments
def get_partition(self, instrument_roll, instrument):
"""entrée:
une ligne du array = (0.0 0.0 0.0 ... 89 ... 91 ... 0.0)
89 est à la position 54
91 est à la position 68
sortie:
une ligne de la liste: 2 notes du même instrument 54 et 68
[(54, 89), (68, 91)] = [(note=54, volume=89), (note=68, volume=91)]
"""
partition = []
# Parcours de toutes les lignes
for n in range(instrument_roll.shape[1]):
# Analyse des lignes pour ne garder que les non nuls
non_zero = np.flatnonzero(instrument_roll[:,n])
notes = []
if non_zero.size > 0:
note = int(non_zero[0])
volume = int(instrument_roll[:,n][note])
if note:
notes.append((note, volume))
partition.append(notes)
# velocity maxi entre 0 et 127
partition = normalize_velocity(partition)
if self.volume == "flat":
partition = flatten_partition(partition)
return partition
def get_instrument_roll(self, partition):
"""Retourne un np.array de (128, FPS*durée du morceau en secondes)"""
# La méthode get_piano_roll marche pour tous les instruments
instrument_roll = partition.get_piano_roll(self.FPS,
np.arange(0,
self.end_time,
1/self.FPS))
return instrument_roll
def save_midi_json(self):
"""Commence par analyser le midi, puis enregistre.
partitions = liste des partitions = [partition_1, partition_2 ...]
instruments = [Instrument(program=71, is_drum=False, name="mélodie"),
...]
json_data = {"partitions": [partition_1, partition_2 ......],
"instruments": [instrument_1.program,
instrument_2.program, ...]
instrument is not JSON serializable = objet pretty_midi
midi dans /media/data/3D/projets/darknet-letters/letters/midi/music
sous dossiers possible
json dans /media/data/3D/projets/darknet-letters/letters/midi/json_fps
et sous dossiers
"""
# Analyse du midi
self.get_partitions_and_instruments()
if len(self.instruments) < 11:
# Création du json
json_data = {}
json_data["partitions"] = self.partitions
json_data["instruments"] = self.instruments
# Save du json
json_name = self.get_json_name()
with open(json_name, 'w') as f_out:
json.dump(json_data, f_out)
f_out.close()
print('Enregistrement de:', json_name)
# Pour Blender
self.end = 1
return self.instruments
def get_json_name(self):
"""Le fichier midi_file est le chemin relatif du fichier dans :
./midi/music/
ou
./midi/music/non_git/
Le json sera dans le dossier
./midi/json_60/
ou
./midi/json_60/non_git/
"""
# Remplacement de l'extension .midi en .json
filename = Path(self.midi_file).with_suffix(".json")
filename = str(filename)
# Remplacement de music par json
json_name = filename.replace("music/",
"json_" + str(self.FPS) + "/")
print("Nom du fichier json", json_name)
# Crée les dossiers et sous dossiers
self.create_directories(json_name)
return json_name
def create_directories(self, json_name):
"""
json_name converti en absolu pour valable ici ou dans blender
json_name = /med/da/3D/pr/dark/let/midi/json_fps_17/toto.json
5
json_fps = /med/da/3D/pr/dark/let/midi/json_fps_17/oui/toto.json
7
"""
json_name_abs = Path(json_name).absolute()
# json_17 doit toujours exister, si existe on passe
index_midi = json_name_abs.parts.index("midi")
# Bidouille pour agréger les parts
a = Path(json_name_abs.parts[0])
b = json_name_abs.parts[1:index_midi + 2]
json_fps = a.joinpath(*b)
# json_fps = Chemin absolu de json_fps
self.mytools.create_directory(json_fps)
# Sous répertoires
if len(json_name_abs.parts) - index_midi == 4:
sd_fin = json_name_abs.parts[1:index_midi + 3]
sd = a.joinpath(*sd_fin)
print("Sous dossier", sd)
self.mytools.create_directory(sd)
# Sous sous répertoires
if len(json_name_abs.parts) - index_midi == 5:
# Création du sous répertoire
sd_fin = json_name_abs.parts[1:index_midi + 3]
sd = a.joinpath(*sd_fin)
print("Sous dossier", sd)
self.mytools.create_directory(sd)
# Création des sous sous répertoires
ssd_fin = json_name_abs.parts[1:index_midi + 4]
ssd = a.joinpath(*ssd_fin)
print("Sous sous dossier", ssd)
self.mytools.create_directory(ssd)
# Resize
img_out = self.change_resolution(img, self.size, self.size)
i += 1
# Save
new_shot = self.get_new_name(shot)
print(new_shot)
cv2.imwrite(new_shot, img_out)
if __name__ == "__main__":
SIZE = 40
# Chemin courrant
abs_path = MyTools().get_absolute_path(__file__)
print("Chemin courrant", abs_path)
# Nom du script
name = os.path.basename(abs_path)
print("Nom de ce script:", name)
# Abs path de semaphore sans / à la fin
parts = abs_path.split("semaphore")
root = os.path.join(parts[0], "semaphore")
print("Path de semaphore:", root)
print("\nResize de toutes les images de training_shot")
rts = ResizeTrainingShot(root, SIZE)
rts.batch()