def normaliser(self, image, coinHautGauche, coinBasDroite):
# On récupère les coordonnées dont on a besoin pour colorer l'image
coinHautGaucheY, coinHautGaucheX = coinHautGauche
coinBasDroiteY, coinBasDroiteX = coinBasDroite
# On compte le nombre de divisions qu'il faut faire sur l'image
nombreDivisions = len(self.fils)
# On calcule la hauteur de chaque subdivision verticale que l'on s'apprète à créer. On rappelle que le 0,0 est tout en haut à gauche de l'image.
hauteur = int((coinBasDroiteY - coinHautGaucheY) / nombreDivisions)
if hauteur == 0:
raise ImageTropPetite(
f"La hauteur d'une liaison parallèle normalisée à la profondeur {self.profondeur} serait 0, la forme de l'arbre est {self.arbre.forme}"
)
# Dans la mesure où l'autoencodeur ne renvoie pas la même valeur de capacité à droite pour tous les fils, nous devons en faire la moyenne ici pour conserver la cohérence par rapport à l'image et ne pas en favoriser une partie.
# On appelle récursivement la méthode dessiner sur les enfants
for i in range(nombreDivisions - 1):
fils = self.fils[i]
coinHautGaucheFils = (
coinHautGaucheY + i * hauteur,
coinHautGaucheX,
)
coinBasDroiteFils = (
coinHautGaucheY + (i + 1) * hauteur,
coinBasDroiteX,
)
fils.normaliser(image, coinHautGaucheFils, coinBasDroiteFils)
# Pour être certain de bien colorer toute l'image et de ne pas laisser des bords noirs à cause de problèmes d'arrondis, on effectue la dernière coloration séparément.
fils = self.fils[-1]
coinHautGaucheFils = (
coinHautGaucheY + (nombreDivisions - 1) * hauteur,
coinHautGaucheX,
)
coinBasDroiteFils = (coinBasDroiteY, coinBasDroiteX)
fils.normaliser(image, coinHautGaucheFils, coinBasDroiteFils)
def lire(self, image, coinHautGauche, coinBasDroite, conteneur):
# On récupère les coordonnées dont on a besoin pour lire l'image
coinHautGaucheY, coinHautGaucheX = coinHautGauche
coinBasDroiteY, coinBasDroiteX = coinBasDroite
if (coinBasDroiteX <= coinHautGaucheX
or coinBasDroiteY <= coinHautGaucheY):
raise ImageTropPetite(
f"Il n'y a pas assez de place pour lire une feuille à la profondeur {self.profondeur}, la forme de l'arbre est {self.arbre.forme}"
)
# On calcule la moyenne des valeurs de coefficients de transmissions sur
# la zone dédiée et on l'affecte à cette feuille.
self.H = max(
np.mean(image[coinHautGaucheY:coinBasDroiteY,
coinHautGaucheX:coinBasDroiteX, 0, ]),
Coefficients.minH,
)
# On calcule la moyenne des valeurs de capacites sur la zone dediée et
# on la renvoie. Notez que l'on a rien à faire avec l'erreur proposée,
# elle n'est qu'un indice en entrée pour aider l'autoencodeur à faire
# son travail.
capaciteDroite = max(
np.mean(image[coinHautGaucheY:coinBasDroiteY,
coinHautGaucheX:coinBasDroiteX, 1, ]),
Coefficients.minC,
)
if conteneur is not None:
conteneur.append(capaciteDroite)
return capaciteDroite
def normaliser(self, image, coinHautGauche, coinBasDroite):
# On récupère les coordonnées dont on a besoin pour colorer l'image
coinHautGaucheY, coinHautGaucheX = coinHautGauche
coinBasDroiteY, coinBasDroiteX = coinBasDroite
# On compte le nombre de divisions qu'il faut faire sur l'image
nombreDivisions = len(self.fils)
# On calcule la largeur de chaque subdivision horizontale que l'on s'apprète à créer. On rappelle que le 0,0 est tout en haut à gauche de l'image.
largeur = int((coinBasDroiteX - coinHautGaucheX) / nombreDivisions)
if largeur == 0:
raise ImageTropPetite(
f"La largeur d'une liaison série écrite à la profondeur {self.profondeur} serait 0, la forme de l'arbre est {self.arbre.forme}"
)
# On appelle récursivement la méthode dessiner sur les enfants
for i in range(nombreDivisions - 1):
fils = self.fils[i]
coinHautGaucheFils = (
coinHautGaucheY,
coinHautGaucheX + i * largeur,
)
coinBasDroiteFils = (
coinBasDroiteY,
coinHautGaucheX + (i + 1) * largeur,
)
# On met à jour la capacité à droite du fils avec la valeur renvoyée par lire
fils.normaliser(image, coinHautGaucheFils, coinBasDroiteFils)
# Pour être certain de bien colorer toute l'image et de ne pas laisser des bords noirs à cause de problèmes d'arrondis, on effectue la dernière coloration séparément.
fils = self.fils[-1]
coinHautGaucheFils = (
coinHautGaucheY,
coinHautGaucheX + (nombreDivisions - 1) * largeur,
)
coinBasDroiteFils = (coinBasDroiteY, coinBasDroiteX)
fils.normaliser(image, coinHautGaucheFils, coinBasDroiteFils)
def elaguerSousArbre(self, coinHautGauche, coinBasDroite):
# Il n'y a rien à faire ici, par hypothès (et par le travail fait sur les liaisons Serie et Parallele) on aura toujours de la place pour une Feuille sur laquelle on appelle la méthode elaguerSousArbre.
coinHautGaucheY, coinHautGaucheX = coinHautGauche
coinBasDroiteY, coinBasDroiteX = coinBasDroite
if (coinBasDroiteX <= coinHautGaucheX
or coinBasDroiteY <= coinHautGaucheY):
raise ImageTropPetite(
f"Un problème est apparu dans l'implémentation de elaguerSousArbre, il n'y a pas assez de place pour mettre une feuille à la profondeur {self.profondeur}. La forme de l'arbre est {self.arbre.forme}"
)
def dessiner(self, image, coinHautGauche, coinBasDroite):
# On récupère le marquage de ce noeud.
rouge, vert, bleu = self.marquage
# On récupère les coordonnées dont on a besoin pour colorer l'image
coinHautGaucheY, coinHautGaucheX = coinHautGauche
coinBasDroiteY, coinBasDroiteX = coinBasDroite
if (coinBasDroiteX <= coinHautGaucheX
or coinBasDroiteY <= coinHautGaucheY):
raise ImageTropPetite(
f"Il n'y a pas assez de place pour écrire une feuille à la profondeur {self.profondeur}, la forme de l'arbre est {self.arbre.forme}"
)
# On colore d'abord les résistances
image[coinHautGaucheY:coinBasDroiteY, coinHautGaucheX:coinBasDroiteX,
0] = rouge
# On colore ensuite les capacités
image[coinHautGaucheY:coinBasDroiteY, coinHautGaucheX:coinBasDroiteX,
1] = vert
# On colore enfin l'erreur
# On colore ensuite les capacités
image[coinHautGaucheY:coinBasDroiteY, coinHautGaucheX:coinBasDroiteX,
2] = bleu
def normaliser(self, image, coinHautGauche, coinBasDroite):
# On récupère les coordonnées dont on a besoin pour normaliser l'image.
coinHautGaucheY, coinHautGaucheX = coinHautGauche
coinBasDroiteY, coinBasDroiteX = coinBasDroite
if (coinBasDroiteX <= coinHautGaucheX
or coinBasDroiteY <= coinHautGaucheY):
raise ImageTropPetite(
f"Il n'y a pas assez de place pour normaliser une feuille à la profondeur {self.profondeur}, la forme de l'arbre est {self.arbre.forme}"
)
# On calcule la moyenne des valeurs de coefficients de transmissions sur
# la zone dédiée on l'affecte à toute la zone.
image[coinHautGaucheY:coinBasDroiteY, coinHautGaucheX:coinBasDroiteX,
0] = np.mean(image[coinHautGaucheY:coinBasDroiteY,
coinHautGaucheX:coinBasDroiteX, 0, ])
# De même on normalise pour les capacités
image[coinHautGaucheY:coinBasDroiteY, coinHautGaucheX:coinBasDroiteX,
1] = np.mean(image[coinHautGaucheY:coinBasDroiteY,
coinHautGaucheX:coinBasDroiteX, 1, ])
# Et enfin pour l'erreur
image[coinHautGaucheY:coinBasDroiteY, coinHautGaucheX:coinBasDroiteX,
2] = np.mean(image[coinHautGaucheY:coinBasDroiteY,
coinHautGaucheX:coinBasDroiteX, 2, ])