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 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)
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()
# 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)
train_num = int(0.9 * nb)
counter = 0
train = ""
test = ""
for f in files:
if counter < train_num:
train += f + "\n"
else:
test += f + "\n"
counter += 1
# Ecriture dans les fichiers
mt.write_data_in_file(test, "test.txt", "w")
mt.write_data_in_file(train, "train.txt", "w")
print("Done.")
# Boucle pour arriver aux nombre de shot à faire
for rep in range(loop):
# Répétition pour avoir une frame vide toutes les ~100
for w in range(6):
nb_lettres = randint(10, 30)
for i in range(nb_lettres):
note = randint(0, 127)
note_vol = [[note, 0]]
part.append(note_vol)
# Frame sans note tous les ~100 (notes, volumes)
part.append([])
partitions.append(part)
# Ajout au dict
json_dict["partitions"] = partitions
print("\n\nNombre de notes par partition:")
for j in range(10):
print(" Partition =", j, "nombre:", len(json_dict["partitions"][j]))
# Json
data = json.dumps(json_dict)
# Fin de ligne à la fin pour github
data += "\n"
f = "get_shot.json"
mode = "w"
tools.write_data_in_file(data, f, mode)