def morph(img1, img2, img1_pts, img2_pts, tri, warp_frac, dissolve_frac)
. Les deux premiers arguments sont le nom des images à allez ouvrir, les deux autres arguments sont les fichiers de points à allez lire pour
les correspondances entres les différents points des images. La variable tri est la structure de triangulation Delaunay de la
librairie python scipy.spatial. J'ai eu un gros problème avec cette librairie. Ce n'est pas que la forme de triangulation était mauvaise,
mais ce qui n'est pas écrit dans la documentation (terriblement mauvaise documentation de la fonction Delaunay de la part de scipy) c'est que
la fonction Delaunay garde en mémoire les points associés à la triangulation initiale, pas possible de changer les origines des points.
Donc ce que je faisais au début était de faire la triangulation toujours au début sur la forme moyenne des points et de simplement changer ensuite
l'origine des points de la structure de triangulation vers les points demandées par warp_frac, donc:
(1 - warp_frac) * points_image_origine + (warp_frac) * points_image_destination
Mais puisque la fonction scipy.spatial.Delaunay ne permet pas ce changement des points "on the fly" je me retrouvais toujours avec la structure de triangulation moyenne, et non pas une triangulation changeant avec le changement de
warp_frac à chaque itération. Je n'utilise donc
que la triangulation Delaunay et ensuite je travaille avec la librairie python matplotlib.tri pour me permettre de changer les points à chaque itération.
La fonction suivante me donne une structure de triangulation voulue avec les points voulues (pts_wanted sont les points qui changent à chaque itération
vers lesquels on veut que les points des deux images fassent leur transformation affine):
triangle_struct = mtri.Triangulation(pts_wanted[:,0], pts_wanted[:,1], tri_moy.simplices)
J'utilise ensuite la fonction tri_finder pour déterminer dans quel triangle de ma structure de triangulation les points à transformer sont:
trifinder = triangle_struct.get_trifinder()
index = trifinder(coordinates[i, 0], coordinates[i, 1])
coord_apres = np.dot(transfo_moy_to_1[index], coord_avant)
Je pense que le travail avec la triangulation est vraiment la partie difficile du TP3, pour moi en tout cas. Parce que sinon le reste à été comme sur des roulettes. L'algorithme va donc comme suit. J'ouvre les deux images à morpher ensemble et je ressort leurs dimensions: hauteur, largeur ainsi que le type de points utilisés dans leur troisième dimension (RGB, etc.). Je travail avec un template représentant l'image morpher de fin de la même forme que les images ouvertes et je le remplie de valeurs bogus (1). J'ouvre ensuite les deux fichiers de points des images et je calcul les points voulues selon la variable
warp_frac. Je transforme ma structure de triangulation Delaunay de scipy vers celle
de matplotlib et j'initialise ma variable de triangle finder.
Je commence ensuite le travail de trouver toutes les transformations affine pour tous les triangles, en partant de l'image voulue (soit celle représentée par
pts_wanted dans le template) vers les deux autres images.
J'ai donc deux fois le nombres de triangles en transformation. Pour la transformation j'ai suivi un petit
stackexchange très explicite pour ce genre de transformation affine (et comment trouver la transformation inverse). Soit la lien suivant:
https://math.stackexchange.com/questions/1092002/how-to-define-an-affine-transformation-using-2-triangles
Le point important que j'ai compris de cette explication est qu'il fallait simplement que je trouve la transformation inverse des points de mon triangle d'origine, ensuite le dot product avec mes points du triangle moyen ce qui me donne la transformation de l'image d'origine vers l'image moyenne. Mais pour avoir la transformation dans l'autre sens, soit de l'image moyenne vers l'image d'origine: simplement faire l'inverse de la transformation.
Je rajoute ensuite simplement un 1 avec le x et y de mes coordonnées pour la troisième dimension de ma transformation. Quand j'ai trouvé toutes mes transformations et que j'ai placé celles-ci dans deux structure de même forme que ma structure de triangulation (
transfo_moy_to_1 et transfo_moy_to_2). Je peux ainsi facilement
retrouver ma transformation associée à mon triangle quand, en itérant sur les points de l'image, je cherche les triangles
associées aux points voulues. C'est justement la dernière étape de mon algorithme ou je trouve grâce à toutes les
transformations les points des images d'origines vers les points de l'image template et que je donne la valeur
de ces pixels selon la variable dissolve_frac :
template[int(coord_avant[1]), int(coord_avant[0])] =
image_1[int(coord_apres[1]), int(coord_apres[0])] * (1 - dissolve_frac) +
image_2[int(coord_derniere[1]), int(coord_derniere[0])] * (dissolve_frac)
Mon algorithme ce termine ainsi et retourne l'image transformée.
