Project done.

main.py

@@ -13,9 +13,9 @@
 import numpy as np
 
 
-PATCH_SIZE = 41
-STEP = PATCH_SIZE
-ALPHA = 0.0001
+PATCH_SIZE = 101
+STEP = PATCH_SIZE // 4
+ALPHA = 0.00001
 MAX_ITERATIONS = 100000
 TOLERANCE = 0.0001
 VALUE_MISSING_PIXEL = VALUE_MISSING_PIXEL
@@ -56,15 +56,19 @@ def main_outdoor():
     main_inpainting(original_picture, noisy_picture)
 
 
-def main_inpainting(original_picture, noisy_picture):
-    inpainting = InPainting(patch_size=PATCH_SIZE, step=STEP, alpha=ALPHA, max_iterations=MAX_ITERATIONS,
-                            tolerance=TOLERANCE, value_missing_pixel=VALUE_MISSING_PIXEL,
-                            value_out_of_bounds=VALUE_OUT_OF_BOUNDS)
+def main_inpainting(original_picture, noisy_picture, patch_size=PATCH_SIZE, step=STEP, alpha=ALPHA,
+                    max_iterations=MAX_ITERATIONS, tolerance=TOLERANCE, value_missing_pixel=VALUE_MISSING_PIXEL,
+                    value_out_of_bounds=VALUE_OUT_OF_BOUNDS, save_path=None):
+    inpainting = InPainting(patch_size=patch_size, step=step, alpha=alpha, max_iterations=max_iterations,
+                            tolerance=tolerance, value_missing_pixel=value_missing_pixel,
+                            value_out_of_bounds=value_out_of_bounds)
     inpainted_picture = inpainting.inpaint(noisy_picture)
+
     # Affichage des résultats
     show_pictures(pictures=[original_picture._get_showable_picture(), noisy_picture._get_showable_picture(),
                             inpainted_picture._get_showable_picture()],
-                  titles=["Original picture", "Noisy picture", "InPainted picture"])
+                  titles=["Original picture", "Noisy picture", "InPainted picture"],
+                  save_path=save_path)
 
 
 def main_all_vs_all():

rapport/rapport.aux

@@ -36,7 +36,9 @@
 \@writefile{toc}{\contentsline {section}{\numberline {2}LASSO et Inpainting}{5}{section.0.2}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Introduction}{5}{subsection.0.2.1}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.1}Principe}{5}{subsubsection.0.2.1.1}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.2}D\IeC {\'e}roulement}{5}{subsubsection.0.2.1.2}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.3}Applications}{5}{subsubsection.0.2.1.3}}
-\memsetcounter{lastsheet}{5}
-\memsetcounter{lastpage}{5}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.2}D\IeC {\'e}roulement \& impl\IeC {\'e}mentation}{5}{subsubsection.0.2.1.2}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}R\IeC {\'e}sultats sur des images bruit\IeC {\'e}es}{6}{subsection.0.2.2}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}R\IeC {\'e}sultats sur des patchs manquants}{7}{subsection.0.2.3}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}De l'importance dans l'ordre de remplissage}{8}{subsection.0.2.4}}
+\memsetcounter{lastsheet}{8}
+\memsetcounter{lastpage}{8}

rapport/rapport.out

@@ -8,5 +8,7 @@
 \BOOKMARK [1][-]{section.0.2}{LASSO et Inpainting}{section*.1}% 8
 \BOOKMARK [2][-]{subsection.0.2.1}{Introduction}{section.0.2}% 9
 \BOOKMARK [3][-]{subsubsection.0.2.1.1}{Principe}{subsection.0.2.1}% 10
-\BOOKMARK [3][-]{subsubsection.0.2.1.2}{D\351roulement}{subsection.0.2.1}% 11
-\BOOKMARK [3][-]{subsubsection.0.2.1.3}{Applications}{subsection.0.2.1}% 12
+\BOOKMARK [3][-]{subsubsection.0.2.1.2}{D\351roulement \046 impl\351mentation}{subsection.0.2.1}% 11
+\BOOKMARK [2][-]{subsection.0.2.2}{R\351sultats sur des images bruit\351es}{section.0.2}% 12
+\BOOKMARK [2][-]{subsection.0.2.3}{R\351sultats sur des patchs manquants}{section.0.2}% 13
+\BOOKMARK [2][-]{subsection.0.2.4}{De l'importance dans l'ordre de remplissage}{section.0.2}% 14

rapport/rapport.tex

@@ -102,12 +102,81 @@ \subsubsection{Principe}
 
 
 \subsubsection{Déroulement \& implémentation}
+Tout d'abord, la \textbf{construction du dictionnaire de patchs} est effectuée : On récupère tous les patchs d'une certaine taille dont le signal est pur (qui ne contiennent pas de pixel manquant).\\
+Ensuite, on va boucler tant qu'il existe encore des pixels manquants dans l'image :
+\begin{itemize}
+\item On détermine le prochain patch à approximer
+\item On fait un apprentissage : Pour chaque emplacement de pixel non-vide du patch cible, on considère que les pixels de chaque patch du dictionnaire au même emplacement peuvent le reconstruire. On constitue donc nos ensembles d'apprentissage de cette façon.
+\item On prédit les valeurs de chaque pixel manquant du patch. 
+\end{itemize}
+
+Ainsi, nous remplissons l'image patch-par-patch et non pixel-par-pixel, pour garder une certaine cohérence spatiale dans notre reconstruction.\\
+
+Enfin, notre implémentation peut être paramétrée selon les critères suivants :
+\begin{itemize}
+\item \textbf{patch\_size} : La taille d'un patch de l'image.
+\item \textbf{step} : Le pas d'itération utilisé pour la construction du dictionnaire.
+\item \textbf{alpha} : L'importance accordée à la sparsité du vecteur de poids. 
+\item \textbf{max\_iterations} : Le seuil d'itérations maximum.
+\item \textbf{tolerance} : Le critère d'optimisation minimum avant arrêt.
+\end{itemize}
 
 
+\newpage
+\subsection{Résultats sur des images bruitées}
+\begin{center}
+\includegraphics[scale=0.55]{res/lena_color_512_0_005.png}\\
+\small{Inpainting de l'image \path{res/pictures/lena_color_512.tif}, $0.5\%$ de l'image bruitée.}
+\end{center}
+\begin{center}
+\includegraphics[scale=0.55]{res/lena_gray_512_0_05.png}\\
+\small{Inpainting de l'image \path{res/pictures/lena_gray_512.tif}, $5\%$ de l'image bruitée.}
+\end{center}
+\begin{center}
+\includegraphics[scale=0.55]{res/lena_color_512_0_1.png}\\
+\small{Inpainting de l'image \path{res/pictures/lena_color_512.tif}, $10\%$ de l'image bruitée.}
+\end{center}
+\begin{center}
+\includegraphics[scale=0.55]{res/lena_color_512_0_5.png}\\
+\small{Inpainting de l'image \path{res/pictures/lena_color_512.tif}, $50\%$ de l'image bruitée.}
+\end{center}
+
+Nous obtenons des résultats visuellement très satisfaisants sur des pixels isolés. Et ce sans trop s'attarder sur les paramètres. Une petite taille de patch est cependant nécessaire pour des images beaucoup bruitées. On remarque aussi la difficulté d'approximer des détails non-redondants de l'image (l’extérieur des plumes, le contour du visage).
+
+
+\newpage
+\subsection{Résultats sur des patchs manquants}
+La reconstruction d'une plus grosse partie d'une image devient un peu plus compliquée. En effet, les patchs à reconstituer étant de taille plus importante, nous disposons de moins d'information pour chaque patch. Il va alors falloir s'y reprendre à plusieurs fois pour trouver de bons paramètres. Testons sur l'image \path{res/pictures/outdoor.jpg} :
+
+\begin{center}
+\includegraphics[scale=0.4]{res/outdoor_gros_alpha.png}\\
+\small{Ici, $\alpha=0.5$, ce qui est trop gros. On effectue une combinaison linéaire avec trop de patchs, ce qui explique cet effet de flou.}
+\end{center}
+
+\begin{center}
+\includegraphics[scale=0.4]{res/outdoor_petit_patch.png}\\
+\small{Ici, $patch\_size=5$, ce qui est trop petit. Les patchs ne contiennent pas assez d'information pour être correctement reconstruit. De plus, les pixels qui viennent juste d'être approximé sont trop pris en compte, ce qui donne un effet un peu ``baveux''.}
+\end{center}
 
-\subsubsection{De l'importance dans l'ordre de remplissage}
-L'ordre dans lequel on choisit de remplir les patchs à toute son importance. En effet, 
 
+\begin{center}
+\includegraphics[scale=0.4]{res/outdoor_peu_iter.png}\\
+\small{Ici, $max\_iterations=1000$, ce qui est trop peu. On dépasse ce seuil avant d'avoir trouvé les poids optimaux pour notre reconstruction.}
+\end{center}
+
+
+\begin{center}
+\includegraphics[scale=0.4]{res/outdoor_parfait.png}\\
+\small{Ici, $\alpha=0.0001,\; patch\_size=101,\; max\_iterations=100.000$. La reconstruction parait visuellement correcte, mais elle peut sûrement être encore améliorée.}
+\end{center}
+
+
+\newpage
+\subsection{De l'importance dans l'ordre de remplissage}
+L'ordre dans lequel on choisit de remplir les patchs à toute son importance. En effet, nous utilisons un remplissage naïf de gauche à droite et de haut en bas. Ceci entraîne cependant une espèce de ``bavure'' (comme dans la deuxième figure obtenue). Ce résultat est décrit dans le papier de recherche $[3]$ donné en référence dans l'énoncé : Nous venons de reconstruire une forme particulière (comme un tronc d'arbre), et en remplissant les pixels juste en dessous à l'itération suivante, nous prendrons trop en compte les pixels que nous venons de reconstruire.\\
+Voici une manière efficace pour remplir un trou :\\
+Tout d'abord, assigner une valeur de \textbf{priorité} à chaque patch. Plus elle est haute, plus il faudra traiter ce patch en premier. On peut décompenser cette priorité en un \textit{produit de deux valeurs} : un coefficient d'\textbf{information}, indiquant à quel point un patch est proche de pixels purs, et un coefficient \textbf{isophotique}, caractérisant la force des \textit{isophotes} (la direction et l'intensité des pixels) autour du patch.\\
+Grossièrement, cette heuristique permet de reconstruire en premier lieu les contours du trou, tout en priorisant les gros changements d'intensité autour du trou (souvent liés à une coupe perpendiculaire au trou).
 
 
 \end{document}

rapport/rapport.toc

@@ -9,5 +9,7 @@
 \contentsline {section}{\numberline {2}LASSO et Inpainting}{5}{section.0.2}
 \contentsline {subsection}{\numberline {2.1}Introduction}{5}{subsection.0.2.1}
 \contentsline {subsubsection}{\numberline {2.1.1}Principe}{5}{subsubsection.0.2.1.1}
-\contentsline {subsubsection}{\numberline {2.1.2}D\IeC {\'e}roulement}{5}{subsubsection.0.2.1.2}
-\contentsline {subsubsection}{\numberline {2.1.3}Applications}{5}{subsubsection.0.2.1.3}
+\contentsline {subsubsection}{\numberline {2.1.2}D\IeC {\'e}roulement \& impl\IeC {\'e}mentation}{5}{subsubsection.0.2.1.2}
+\contentsline {subsection}{\numberline {2.2}R\IeC {\'e}sultats sur des images bruit\IeC {\'e}es}{6}{subsection.0.2.2}
+\contentsline {subsection}{\numberline {2.3}R\IeC {\'e}sultats sur des patchs manquants}{7}{subsection.0.2.3}
+\contentsline {subsection}{\numberline {2.4}De l'importance dans l'ordre de remplissage}{8}{subsection.0.2.4}

src/common/matplotlib.py

@@ -4,7 +4,7 @@
 from matplotlib import pyplot as plt
 
 
-def show_pictures(pictures: iter, titles: List[str] = None, columns: int = 1):
+def show_pictures(pictures: iter, titles: List[str] = None, columns: int = 1, save_path: str = None):
     """ Display a list of images in a single figure with matplotlib.
 
     :param pictures: List of np.arrays compatible with plt.imshow
@@ -29,6 +29,10 @@ def show_pictures(pictures: iter, titles: List[str] = None, columns: int = 1):
         sub_figure.set_title(title)
         sub_figure.axis("off")
     fig.set_size_inches(np.array(fig.get_size_inches()) * len(pictures))
+
+    if save_path is not None:
+        plt.savefig(save_path)
+        plt.imread(save_path)
     plt.show()
 
 

src/inpainting.py

@@ -46,7 +46,6 @@ def inpaint(self, picture: Picture) -> Picture:
 
         while self.value_missing_pixel in picture.pixels:
             # On récupère le prochain patch à traiter
-            # TODO: parfois, patch est vide
             next_pixel = self._get_next_patch(picture, self.patch_size, self.value_out_of_bounds,
                                               self.value_missing_pixel)