migrate 455 from drive

455-Codage_Sources/Cours/chap0.tex

@@ -0,0 +1,167 @@
+\documentclass[main.tex]{subfiles}
+
+\begin{document}
+
+\paragraph{Pourquoi a-t-on besoin du codage de source ?}
+
+Un téléviseur HD affiche des images de 1920 x 1080 pixels. Chaque pixel est formé d'une combinaison de 3 couleurs RGB, chacune des couleurs étant codée par un nombre sur 8, 10 ou 12 bits. À raison de 25, 50 ou 60 images par seconde, le débit nécessaire est R= 1920 x 1080 x 3 x 8 x 25 = 1,22 Gbits par seconde. \\
+
+En 4G, le débit maximal est de 100 Mbits par seconde (quand on est seul dans la zone) et en ADSL, il est de 20 Mbits par seconde.
+
+Il faut compresser les données avec un facteur 100 au minimum.\\
+
+\emph{"Le taux minimum c'est 25 images par seconde, pour pas avoir l'impression de regarder un dessin animé japonais."}
+\emph{"Des émissions mettent volontairement moins pour qu'on ait l'impression d'avoir trop bu en regardant la télé."}\\
+
+\paragraph{Comment faire de la compression?} Quelles propriétés du signal vidéo peut-on utiliser pour réaliser de la compression?
+On utilise la redondance statistique. Par exemple, pour la vision (ou tech 3D) on utilise les petites différences pour obtenir la profondeur. De la même façon, en stéréo on a deux micros pour l'enregistrement. C'est la ressemblance entre les deux signaux qui nous intéresse ici pour effectuer la compression.\\
+
+La compression est possible à cause de plusieurs propriétés:
+\begin{itemize}
+\item La corrélation temporelle (ressemblance entre deux image successives d'une vidéo ou échantillons audio successifs).
+\item La corrélation spatiale (le fait que certaines zones présentes sont relativement uniforme, ressemblance entre deux pixels voisins).
+\item La corrélation spectrale (ressemblance entre les composantes R, G et B d'une image).
+\item Les propriétés statistiques du signal (un texte contient plus de "e" que de "z" en général).
+\end{itemize}
+
+\paragraph{Exemple d'une chaîne de compression vidéo}
+On considère une vidéo mono-vue (pas en 3D) codée en niveaux de gris.\\
+
+\underline{Transformation}: On applique une transformation à l'image, c'est à dire que l'on cherche à exprimer les blocs de l'image dans une base autre que la base canonique, pour permettre une compression plus facile.\\
+Par exemple :
+
+$\begin{pmatrix}1&1\\1&1\end{pmatrix}$ permet de décrire les zones constantes
+
+$\begin{pmatrix}1&1\\-1&-1\end{pmatrix}$ pour décrire les variations verticales, et
+
+$\begin{pmatrix}1&-1\\1&-1\end{pmatrix}$ pour une variation horizontale.\\
+
+\underline{Quantification}: Elle permet de représenter les pixels transformés sur un nombre limité de bits (et d'en mettre plein à 0). Cette opération est irréversible.\\
+
+\underline{Codeur entropique}: Il exploite la redondance statistique des coefficients quantifiés (il prend les successions et les compresse). On ne peut pas encore envoyer les données sur le réseaux, il faut appliquer un standard de compression.\\
+
+\underline{Standard de compression}: Détermine la manière dont les bits en sortie sont organisés. (constitue les paquets, les numérote etc.)\\
+
+
+On peut alors transmettre l'image. Une fois récupérée, on applique un décodage entropique, puis un désindexation et enfin une transformation inverse.\\
+
+La désindexation permet d'obtenir à partir d'un coefficient quantifié, un nombre qui a la même dynamique qu'un coefficient transformé.(exemple: permet de retrouver un nombre à la bonne échelle, même si ce nombre n'est pas exactement le même).
+\begin{figure}[H]
+  \centering
+\begin{tikzpicture}
+  \sbEntree{E}
+  \sbBlocL{t}{Transformée}{E}
+  \sbBlocL{q}{Quantificateur}{t}
+  \sbBlocL{c}{Codeur entropique}{q}
+  \sbSortie{S}{c}
+\end{tikzpicture}
+\begin{figure}[H]
+  \centering
+
+  \caption{utilisation d'un décodeur local}
+\end{figure}
+\caption{Chaine de compression}
+\end{figure}
+
+
+\begin{figure}[H]
+  \centering
+\begin{tikzpicture}
+  \sbEntree{E}
+  \sbBlocL{d}{decodeur entropique}{E}
+  \sbBlocL{D}{Désindexeur}{d}
+  \sbBlocL{t}{Transformée inverse}{D}
+  \sbSortie{S}{t}
+\end{tikzpicture}
+\caption{Chaine de décompression}
+\end{figure}
+
+\paragraph{Comment transmettre une vidéo?} appliquer ce shcéma (JPEG) à chaque image et transmettre? non, trop lourd.
+On peut comparer l'image 2 à l'image précédente non pas 1 mais $\hat{1}$ l'estimée de l'image reçue par le récepteur, et l'on envoie la différence. Puis pour envoyer l'image 3, on estime la différence précédente, on y ajoute l'image estimée de la première image et on calcule la différence, que l'on envoie au travers des différentes transformations. Et ainsi de suite.\\
+
+De ce fait, au niveau du récepteur on mémorise l'image précédente à laquelle on ajoute les différences.\\
+
+Cette structure de codeur était celle des premiers codeurs vidéo (H261, MPEPZ). H265 encore utilisé a aussi cette structure.\\
+
+\noindent Notations :\\
+$I_n$: image numéro n\\
+$\hat{I_n}$ : image numéro n au décodeur\\
+$f(\hat{I_n}) = \tilde{I_{n+1}}$: image n+1 prédite\\
+
+
+On va étudier deux cas :
+\begin{enumerate}
+\item pas de décodeur au niveau du codeur mais on a un prédicteur.
+\begin{align*}
+\tilde{I_{n+1}} &= T^{-1}(Q^{-1}(Q(T(I_{n+1} - f(I_n))))) + \tilde{I_{n+1}}\\
+&= I_{n+1} - f(I_n) + E_{n+1} + \tilde{I_{n+1}} \text{	avec, E le bruit}
+\end{align*}
+$f(I_n)$ et $\tilde{I_{n+1}}$ ne se compensent pas totalement.
+\bigbreak
+
+\item On fait la prédiction a partir des images codées précédemment.
+\begin{align*}
+\tilde{I_{n+1}} &= T^{-1}(Q^{-1}(Q(T(I_{n+1} - f(\hat{I_n}))))) + f(\hat{I_n}\\
+&= I_{n+1} - f(\hat{I_n}) + E_n +f(\hat{I_n})\\
+&= I_{n+1} + E_n
+\end{align*}
+L'utilisation d'un décodeur au niveau du codeur (décodeur local) permet d'éviter une accumulation des erreurs au niveau des images décodées.
+\end{enumerate}
+\begin{figure}[H]
+  \centering
+  \begin{tikzpicture}[thick,scale=0.9, every node/.style={scale=0.9}]
+    \sbEntree{E}
+    \node[above] at (E) {...$I_2,I_1$};
+    \sbComp{a}{E}
+    \sbRelier{E}{a}
+    \sbBlocL[6]{c}{Transformée}{a}
+    \sbBlocL[6]{d}{Quantification}{c}
+    \sbBlocL[5]{e}{
+      \begin{tabular}{c}
+        Codeur\\ entropique
+      \end{tabular}}{d}
+    \sbSortie{s}{e}
+    \sbRelier{e}{s}
+    \sbDecaleNoeudy[10]{d-e}{Ret}
+    \sbBlocr{D}{Désindéxation}{Ret}
+    \sbBlocrL{T}{
+        \begin{tabular}{c}
+          Transformée\\inverse
+        \end{tabular}}{D}
+    \sbRelieryx{d-e}{D}
+    \sbCompSum[-6]{C1}{T}{+}{ }{ }{+}
+    \sbRelier{T}{C1}
+    \sbBlocrL{m}{Mémoire}{C1}
+    \sbRelierxy{m}{a}
+    \sbDecaleNoeudx[5]{m-a}{int}
+    \node[left] (is) at (m-a){};
+    \node[left=0.5em] at (m-a) {$\hat{I_1}$};
+    \node[right] (ie) at (int){};
+    \draw[-] (is) to[spst] (ie);
+    \sbRelierxy{int}{C1}
+  \end{tikzpicture}
+  \caption{Utilisation d'un décodeur local}
+\end{figure}
+
+\begin{figure}[H]
+  \centering
+  \begin{tikzpicture}
+  \sbEntree{E}
+  \sbBlocL{d}{\begin{tabular}{c}
+                decodeur \\entropique
+              \end{tabular}}{E}
+  \sbBlocL{D}{Désindexeur}{d}
+  \sbBlocL{t}{\begin{tabular}{c}
+          Transformée\\inverse
+        \end{tabular}}{D}
+  \sbCompSum[8]{c}{t}{ }{+}{+}{ }
+  \sbRelier{t}{c}
+  \node[below=4em,rectangle,draw](m) at (c) {Mémoire};
+  \sbRelier{m}{c}
+  \sbSortie{S}{c}
+  \sbRelier[$\hat{I_2}\hat{I_1}$]{c}{S}
+  \end{tikzpicture}
+  \caption{Décodeur à mémoire}
+\end{figure}
+
+\end{document}

455-Codage_Sources/Cours/chap0_MAN.tex

@@ -0,0 +1,85 @@
+\documentclass[main.tex]{subfile}
+
+\lstset{language=Matlab}
+
+\begin{document}
+\section{Rappels mathématiques pour le codage de source}
+
+\paragraph{Signaux et variables aléatoires}
+Les signaux qu'on cherche à compresser (texte, échantillons de voix, musique, images, vidéo...) sont décrits comme des réalisations de suites de variables aléatoires.\\
+
+Une variable aléatoire $X$ est décrite par son domaine $\X$, c'est-à-dire l'ensemble des valeurs que $X$ peut prendre (aussi appelé alphabet).
+
+$\X$ peut être à valeurs discrètes (par exemple singletons $\in\{0,1\}, \quad \{0,\dots 255\}$,  ou triplets $\{(0,0,0)...(255,255,255)\}$ dans le cas de couleurs), ou à valeurs continues ($\in \R$, un intervalle $[a,b]\subset\R$)
+
+\section{Variables aléatoires discrètes}
+
+$X$ est en plus caractérisée par sa \emph{probability mass function} (loi de probabilité) $p_i = Pr(X=i), \quad i \in \X$
+
+Les $p_i$ sont tels que :
+\begin{itemize}
+\item $p_i \geq 0, \quad \forall i \in \X$
+\item $\sum_{i \in \X}p_i = 1$
+\end{itemize}
+
+\medskip
+
+\paragraph{Moyenne de $X$} (ou espérance) : $E(X)=\sum_{i \in \X} i p_i$
+
+\begin{exemple}
+$\X=\{1,2,3\}$ avec $p=1 = 0.5, p_2=0.25, p_3=0.25$.
+
+On a $E(X) = 1\times0.5 + 2\times0.25 + 3\times0.25 = 1.75$
+\end{exemple}
+
+\paragraph{Variance de X} : $V(x)=E[(X-E(X))^2] = \sum_{i\in\X} (i-E(x))^2p_i$
+
+\begin{exemple}[(suite)]
+$\X=\{1,2,3\}$ avec $p=1 = 0.5, p_2=0.25, p_3=0.25$.
+
+On a $V(x) = (1-1.75)^2\times0.5 + (2-1.75)^2\times0.25 + (3-1.75)^2\times0.25=0.69$
+\end{exemple}
+
+\paragraph{Écart-type de X} $ \sigma(X) = \sqrt{V(X)}$
+
+\medskip
+\begin{exemple}[Générer des réalisations de VA]
+Génération d'une suite de réalisations d'une VA $X$ tel que $\X=\{0,1\}$ avec $p_0=0.9,\quad p_1=0.1$
+
+\begin{lstlisting}
+x=rand(1,10)>0.9
+% rand : générateur de loi uniforme
+% randn : générateur de loi gaussienne
+\end{lstlisting}
+
+\noindent Pour générer une suite de réalisations correspondant aux exemples précédents
+
+\begin{lstlisting}
+x=rand(1,10)
+y= (x<0.5) + 2*(x<0.75 & x>0.5) + 3*(x>0.75)
+\end{lstlisting}
+\end{exemple}
+
+\medskip
+On considère deux variables aléatoires $X_1$ et $X_2$ d'alphabet $\X$.
+
+\paragraph{Indépendance}
+$X_1$ et $X_2$ sont indépendantes si et seulement si \[Pr(X_1=i,X_2=j)=Pr(X_1=i).Pr(X_2=j)\]
+
+Ainsi $E(X_1X_2)=E(X_1).E(X_2)$\\
+
+Dans le cas général,
+\[Pr(X_1=i,X_2=j)=Pr(X_1=i / X_2=j).Pr(X_2=j)=Pr(X_2=j / X_1 =i).Pr(X_1=i)\]
+
+Si $X_1$ et $X_2$ sont indépendants $Pr(X_1=i/X_2=j)=Pr(X_1=i)$ pour tous $i,j$
+
+$\sum_{j\in\X}Pr(X_2=j/X_1=i)=1$ mais $\sum_{i\in\X} Pr(X_2=j/X_1=i)= ?$
+
+\paragraph{Marginalisation}
+
+On suppose connaître $Pr(X_2=j/X_1=i)$ et $Pr(X_1=i)$.
+
+D'après la règle du produit,
+
+\[Pr(X_2=j)=\sum_{i\in\X} Pr(X_2=j,X_1=i) = \sum_{i\in\X} Pr(X_2=j/X_i=i).Pr(X_1=i)\]
+\end{document}

455-Codage_Sources/Cours/chap1.tex

@@ -0,0 +1,504 @@
+\documentclass[main.tex]{subfiles}
+
+% Corrigé jusqu'à II.2 inclus. A 03/03/15
+% Corrigé en entier. A 22/04/15
+
+\begin{document}
+\newcommand{\X}{\mathcal{X}}
+\section{Modèles de sources}
+
+On s'intéresse à la compression sans perte d'un message constitué de symboles appartenant à un alphabet fini $\X$.\\
+
+Ces symboles sont:
+\begin{itemize}
+\item les caractères d'un texte
+\item la sortie du quantificateur d'un codeur vidéo.
+\item ...
+\end{itemize}
+\bigbreak
+On fait l'hypothèse que le message est une réalisation d'une suite de variables aléatoires $X_1$,...,$X_n$.\\
+
+\subsection{Modèle stationnaire sans mémoire}
+
+C'est le modèle le plus simple, on suppose que:
+\begin{itemize}
+\item les VA $x_i$ sont distribuées de la même manière, quelque soit $n$ (stationnarité).
+\item les VA sont indépendantes entre elles.
+\end{itemize}
+\smallbreak
+C'est un mauvais modèle, mais il est simple.
+
+Pour décrire ce modèle, il suffit de disposer de $p_i = Pr(X_n=i), \quad \forall i \in \X$.\\
+
+\begin{exemple}
+On considère une source binaire $X$, à valeurs dans $\X = \{0,1\}$, et
+
+\[p_0 = Pr(X=0),\quad p_1 = Pr(X=1) = 1 - p_0\]
+\end{exemple}
+
+\begin{defin}[Information]
+L'information associée à chaque symbole de la VA X est \[I(i) = -log_2 p_i \text{ (en bits/symbole)} \]
+\end{defin}
+
+\begin{rem}
+C'est une fonction décroissante sur ]0,1] qui s'annule en 1. En effet, l'information associée à quelque chose de certain ($p_i=1$) est nulle, alors que celle associée à quelque chose de peu probable ($p_i\rightarrow 0$) est très grande $(\rightarrow \infty)$.
+\end{rem}
+
+\begin{defin}[Entropie]
+L'information moyenne associé aux symboles de $X$ ou à $X$ est appelée entropie de la source $X$.
+ \[H(X) = -\sum_{i\in\X}p_i log_2(p_i) = \sum_{i\in\X}p_i log_2(\frac{1}{p_i})\]
+\end{defin}
+
+
+On rappelle que $log_2(2^n)=n$.
+
+\begin{exemple}
+ Pour la source binaire:
+
+ si $p_0 = 0.5$ et $p_1 = 0.5$ alors $H(X) = 1$ bit/symbole.
+
+ si $p_0 = 0.01$ et $p_1 = 0.99$ alors $H(X) = 0.08$ bit/symbole.
+\end{exemple}
+
+\begin{prop}
+Propriété de l'entropie\\
+
+On considère deux VA $X_1$ et $X_2$ indépendantes et identiquement distribuées (iid).
+\begin{align*}
+H(X_1,X_2) &= - \sum_{i\in \X, j \in \X} Pr(X_1=i,X_2=j)log_2(Pr(X_1=i,X_2=j))\\
+&= H(X_1)+H(X_2)\\
+&= 2H(X_1)
+\end{align*}
+Plus généralement, si on a N VA iid alors $H(X_1,...,X_N) = N(H(X_1))$.\\
+Et on a $\boxed{H(X) \leq log_2|\X|}$ (nombre d'élément de $\X$).
+\end{prop}
+
+\subsection{Modèle de Markov d'ordre 1}
+
+\noindent Dans ce modèle, la probabilité d'apparition du symbole $n$ ne dépend que de la réalisation du symbole $n-1$. \\
+
+Les probabilités de transition vérifient donc :
+\[Pr(X_n=a_n|X_{n-1} = a_{n-1},X_{n-2} = a_{n-2},...,X_{1} = a_{1}) = Pr(X_n = a_n |X_{n-1} = a_{n-1})\]
+
+On considère des sources de Markov d'ordre 1 stationnaires, donc:
+\[Pr(X_n=a_n|X_{n-1} = a_{n-1}) = Pr(X_{n-1} = a_n | X_{n-2} = a_{n-1}), \forall n\]
+
+Pour décrire une source de Markov d'ordre 1 stationnaire, il suffit de décrire ses probabilités de transition :
+\[Pr(X_{n}=i|X_{n-1}=j) = p_{i|j},\quad \forall i \in \X, \forall j \in \X\]
+
+\begin{exemple}
+Comment estimer les probabilités de transition ?
+on a la séquence : a a b b a c a b b a\\
+\paragraph{Modèle sans mémoire} on estime $\hat{p_a} = \frac{5}{10}$, $\hat{p_b} = \frac{4}{10}$ et $\hat{p_c} = \frac{1}{10}$\\
+
+\paragraph{Modèle de Markov d'ordre 1}
+\begin{align*}
+Pr(X_{n}=i,X_{n-1}=j) &= Pr(X_{n}=i|X_{n-2}=j)Pr(X_{n-1}=j)\\
+&= \frac{Pr(X_{n}=i,X_{n-2}=j)}{Pr(X_{n-1}=j)}
+\end{align*}
+Avec $j=a$, si $i=a$ alors \[Pr(X_n=a|X_{n-1}=a) = \frac{\text{nombre de paires aa}}{\text{nombre de paires débutant par a}}=\frac{1}{4}\]
+si $i = b$ alors \[Pr(X_n=b|X_{n-1}=a) = \frac{\text{nombre de paires ab}}{\text{nombre de paires débutant par a}}=\frac{2}{4}\]
+
+\end{exemple}
+
+On range ces probabilités de transition dans une matrice :
+\[\underline{\underline{P}} = (p_{a_j|a_i})_{(i,j)} = \begin{pmatrix}
+p_{a_1|a_1} & p_{a_2|a_1} & \dots & p_{a_j|a_1}\\
+p_{a_1|a_2} & p_{a_2|a_2} & \dots & p_{a_j|a_2}\\
+\vdots & & & \\
+p_{a_1|a_J} & p_{a_2|a_j} & \dots & p_{a_J|a_J}\\
+\end{pmatrix} \quad \text{avec $J = |\X|$ nombre d'éléments de $\X$}\]
+
+
+\begin{exemple}
+On considère une source de Markov binaire:
+\[p_{0|0} = 0.9, \quad p_{1|0} = 0.1, \quad p_{0|1} = 0.3, \quad p_{1|1} = 0.7\]
+On a donc :
+\[\underline{\underline{P}} = \begin{pmatrix}
+0.9&0.1\\0.3&0.7
+\end{pmatrix}\]
+\end{exemple}
+
+Pour cette source de Markov, on peut être intéressé par les probabilités stationnaires $Pr(x_n=i)$ et on note :
+\begin{align*}
+\underline{\Pi} &= (Pr(X_n=a_1), \dots, Pr(X_n = a_J))\\
+&= (p_{a_1},...,p_{a_J})
+\end{align*}
+
+On peut montrer que $\underline{\Pi}$ satisfait :
+\[\boxed{\underline{\Pi} = \underline{\Pi}\underline{\underline{P}}}\]
+
+\begin{rem}
+On peut aussi voir ce résultat sous la forme plus courante $\underline{\Pi}^T = \underline{\underline{P}}^T \underline{\Pi}^T$. Ceci permet notamment de calculer $\underline{\Pi}$ s'il n'est pas donné, en cherchant un vecteur propre de $\underline{\underline{P}}^T$.
+\end{rem}
+
+\paragraph{Entropie d'une source de Markov d'ordre 1}
+
+\begin{align*}
+H(X) &= -\sum_{i \in \X}p_i\sum_{j \in \X}p_{i|j}log_2(p_{i|j})\\
+&= -\sum_{i \in \X}\sum_{j \in \X}p_{i,j}log_2(p_{i|j})
+\end{align*}
+où $p_{i,j} = Pr(X_n = i, X_{n-1} = j)$\\
+
+\underline{Remarque}: Avec un modèle de Markov, si on essaie de "créer" des mots lettre par lettre, plus on monte dans les ordres, plus la structure de la langue commence à apparaître. À partir de l'ordre 3, il apparaît des mots qui seraient potentiellement de la langue considérée. Ce modèle peut être adapté, comme par exemple pour le correcteur orthographique des téléphones.\\
+
+L'idée générale de la compression d'une source de Markov est d'effectuer des prédictions pour avoir accès aux informations, de sorte qu'il ne reste à transmettre que ce que l'on ne peut pas prédire.\\
+
+\newpage
+\section{Codes}
+
+\subsection{Définitions et propriétés}
+On considère une source $X$ à valeurs dans $\X = \{a_1,..a_J\}$.
+
+\begin{defin}[Code]
+Un code est un ensemble binaire de $\{0,1\}^*$  (union de tous les ensembles $\{0,1\}^2 = \{00,11,01,10\}$ , $\{0,1\}^3 = ...$ ...). Un code est donc un sous-ensemble de $\{0,1\}^*$.\\
+\end{defin}
+
+\begin{defin}[Fonction de codage]
+Une fonction de codage $c : \X \rightarrow C$ associe à chaque élément de $\X$, un élément de C.\\
+\end{defin}
+
+\begin{defin}[Longueur d'un mot de code]
+La longueur d'un mot de code associé à $x \in \X$ est notée \[l(x) = l(c(x)) = \text{ nombre de bits de } c(x)\]
+Pour une source sans mémoire avec $p_j = Pr(X=a_j)$. La longueur moyenne du code C associé à $\X$ est:
+\[\overline{l} = \sum_{j=1}^J p_jl(a_j)\]
+\end{defin}
+
+L'objectif du codage sans perte est de minimiser $\overline{l}$ tout en étant capable de décoder le code sans ambiguïté.
+
+
+\begin{defin}
+Un code $C$ (et sa fonction de codage associée $c$) est dit non singulier si:
+\[x_1 \neq x_2 \Rightarrow c(x_1) \neq c(x_2) \]
+\end{defin}
+
+
+\begin{defin}
+L'extension $C^*$ d'un code $C$ est l'ensemble de toutes les suites, finies et infinies, de mots provenant du code $C$.
+
+\begin{exemple}
+Si C $=\{0,10\}$ alors $\{C^*=\{0,10,00,010,100,000,1010,...\}$
+\end{exemple}
+\end{defin}
+
+\begin{prop}
+Un code C est décodable de façon unique si son extension $C^*$ est non singulière.\\
+Si on prend deux successions de symboles dans $\X$:
+\[x_1x_2...x_N \neq x_1'x_2'...x_{N'} \Rightarrow c(x_1,...x_N)=c(x_1)c(x_2)...c(x_N) \neq c(x_1')...c(x_N')\]
+\end{prop}
+
+\begin{defin}
+Un code C est un code préfixe si aucun mot de code n'est le début d'un autre mot de code.\\
+
+\begin{exemple}
+$\X = \{1,2,3,4\}$\\
+
+\begin{center}
+\begin{tabular}{|c||c|c|c|c|}
+\hline
+X & Singulier & Non singulier & Décodable de manière unique & Préfixe \\
+\hline
+\hline
+1 & 0 & 0 & 10 & 0 \\
+\hline
+2 & 0 & 010 & 00 & 10 \\
+\hline
+3 & 0 & 01 & 11 & 110 \\
+\hline
+4 & 0 & 10 & 110 & 111 \\
+\hline
+\end{tabular}
+\end{center}
+
+\end{exemple}
+\end{defin}
+
+\begin{rem}
+"Décodable de manière unique" implique "Non singulier".
+\end{rem}
+
+\subsection{Inégalités}
+
+\paragraph{Inégalité de Kraft}
+Un code binaire préfixe peut exister à condition que ses longueurs de mot de code $l_1,...l_J$ satisfassent:
+\[\sum_{j=1}^J2^{-l_j} \leq 1 \]
+
+
+\begin{proof} Condition nécessaire : \\
+Soit $l_{max}$ la plus grande des longueurs.
+Le nombre de feuilles à la profondeur $l_{max}$ que peut porter un arbre dont la racine est à la profondeur $l_j$ est $2^{l_{max}-l_j}$.\\
+
+Le nombre maximum de feuilles d'un arbre de profondeur $l_{max}$ est $2^{l_{max}}$.\\
+
+On a $\sum_{j=1}^J2^{l_{max}-l_j} \leq 2^{l_{max}}$ d'où le résultat.\\
+
+Condition suffisante : ?
+\end{proof}
+
+\paragraph{Inégalité de Kraft-McMillan}
+Un code binaire décodable de manière unique peut exister à condition que ses longueurs de mot de code $l_1,...l_J$ satisfassent:
+ \[\sum_{j=1}^J2^{-l_j} \leq 1 \]
+
+
+\begin{rem}
+Attention, ce sont des théorèmes d'existence : ils ne peuvent pas servir à vérifier qu'un code est préfixe ou décodable de manière unique.
+
+\begin{exemple}
+Le code $\{1,00,10\}$ n'est pas préfixe, pourtant on a $\sum 2^{-l_i} = 2^{-1} + 2^{-2} + 2^{-2} = 1$. On sait seulement qu'il existe un code préfixe dont les mots de code ont ces longueurs.
+\end{exemple}
+\end{rem}
+
+\begin{rem}
+On sait que "préfixe" implique "décodable de manière unique". En revanche, si un code est décodable de manière unique, on peut seulement dire qu'il existe un code préfixe équivalent, sans qu'il soit le même.
+\end{rem}
+
+\paragraph{Corollaire} Pour qu'un code binaire soit préfixe (ou décodable de manière uniquer), \emph{il faut} que ses longueurs de mot de code $l_1,...l_J$ satisfassent:
+\[\sum_{j=1}^J2^{-l_j} \leq 1 \]
+
+ \newpage
+\subsection{Code de longueur minimale}
+On considère une source $X$ sans mémoire d'alphabet $\X = \{a_1,...,a_J\}$ et de probabilités $p_j = Pr(X=a_j)$.
+On souhaite construire un code préfixe de longueur moyenne minimale associé à $X$.\\
+
+Si on note $l_1,...,l_J$ les longueurs des mots de codes associés à $a_1,...a_J$ la longueur moyenne sera:
+\[\overline{l}=\sum_{j=1}^Jp_jl_j\]
+
+On cherche à minimiser $\overline{l}$ en s'assurant que le code reste préfixe, c'est à dire que:
+ \[\sum_{j=1}^J2^{-l_j} \leq 1 \text{ ou } \sum_{j=1}^J2^{-l_j} - 1 \leq 0\]
+
+C'est un problème d'optimisation sans contrainte que l'on résout en introduisant le Lagrangien:
+ \[L(l_1,...l_J,\mu) = \sum_{j=1}^Jp_jl_j + \mu\times (\sum_{j=1}^J2^{-l_j} - 1) \text{  avec $\mu$ le multiplicateur de Lagrange}\]
+
+Une condition nécessaire d'optimisation est que:
+ \[\left\{ \begin{matrix}
+ \frac{\partial L}{\partial l_j}=0 & \forall j=1,...,J\\
+ \frac{\partial L}{\partial \mu} = 0
+ \end{matrix}\right.\]
+
+ On a donc:
+ \[
+   \begin{cases}
+     \frac{\partial L}{\partial \mu} & = \sum_{j=1}^J2^{-l_j} - 1 = 0 \\
+     \frac{\partial L}{\partial l_j} & = p_j-\mu. 2^{-l_j}.\ln2 = 0 \text{	, }\forall j=1,...,J
+   \end{cases}
+\]
+
+ En sommant ces égalités et en injectant l'égalité précédente de Kraft, on obtient:
+ \[\mu = \frac{1}{ln2}\]
+
+ En remplaçant dans $p_j-\mu. \ln2. 2^{-l_j} = 0$, et en passant au log en base 2:
+ \[\boxed{l_j = -log_2p_j}\]
+ \bigbreak
+ \bigbreak
+ Pour ce choix de longueurs de mots de code, on obtient:
+ \[ \boxed{ \overline{l} = \sum_{j=1}^J p_j(-log_2p_j) = H(x)}\]
+ Le meilleur code préfixe a une longueur moyenne au minimum égale à l'entropie de la source.\\
+
+ \begin{rem}
+ L'entropie (avec une source sans mémoire) donne une borne supérieure de la quantité d'information réelle contenue dans un message. Dans le cas d'un texte, l'entropie au sens d'une source de Makorv diminue quand on augmente l'ordre, jusqu'à se stabiliser au bout d'un certain ordre.
+ \end{rem}
+
+\newpage
+\subsection{Codage de Huffmann}
+
+On considère une source $X$ à valeurs dans $\X$, de probabilités associées $p_i=Pr(X=a_i)$, pour $a_i\in\X$.
+
+\paragraph{Code préfixe à longueur minimale}
+Pour qu'un code à longueur variable préfixe $C$ de longueurs de mots de code $l_1,...,l_j$ soit un code de Huffmann, il faut que :
+\begin{itemize}
+\item $p_i \leq p_j \Rightarrow l_i \geq l_j, \forall i,j$
+\item les deux mots de codes associés aux symboles les moins probables aient la même longueur
+\item parmi tous les mots de code de longueur maximale, deux d'entre eux ne diffèrent que par le dernier bit.
+\end{itemize}
+
+\paragraph{Principe d'un code de Huffmann}
+À partir de ces propriétés, on peut fabriquer un code de Huffmann.
+
+Initialement, on considère une source $X^{(0)}$ à $J$ symboles $\X=\{a_1,\dots a_J\}$
+
+\begin{enumerate}
+\item On identifie les deux symboles $a_i^{(0)}$ et $a_j^{(0)}$ les moins probables, avec les probabilités associées $p_i^{(0)}$ et $p_j^{(0)}$
+\item On fabrique une source fictive $X^{(1)}$ émettant tous les symboles de $\X$ sauf $a_i^{(0)}$ et $a_j^{(0)}$, remplacé par le symbole fictif $a_{ij}^{(0)}$ de probabilité $p_i^{(0)}+p_j^{(0)}$.
+
+$\X^{(1)}$ comporte $J-1$ éléments.
+
+\item On répète 1 et 2 jusqu'à ce qu'il n'y ait plus que deux symboles.
+\end{enumerate}
+
+Au bout de $J-2$ itérations, il reste deux symboles $\X^{(J-2)} = \{a_1^{(J-2)},a_2^{(J-1)}\}$. Le premier est identifié avec un 0, le second avec un 1.\\
+
+Si $a_1^{(J-2)}$ est un symbole fictif résultant du regroupement de deux symboles $a_1^{(J-3)}$ et $a_2^{(J-3)}$ alors le code associé à ces deux symboles est obtenu en rajoutant 0 ou 1 au code associé à $a_1^{(J-2)}$.\\
+
+Plus généralement, si $\underline{C}$ est le code associé au symbole fictif $a_i^{k)}$ résultant du regroupement de $a_i^{(k-1)}$ et $a_j^{(k-1)}$, alors le code de $a_i^{(k-1)}$ sera $\underline{C} 0$ et le code de $a_j^{(k-1)}$ sera $\underline{C} 1$.\\
+
+\paragraph{Propriétés}
+On peut montrer que la longueur moyenne $\overline{l}$ d'un code de Huffmann associé à une source satisfait \[ H(x) \leq \overline{l} \leq H(X) +1 \]
+
+On peut obtenir des codes plus performants en codant des paires de symboles, des triplets... des N-uplets de symboles. Avec ce type de technique, la longueur moyenne $\overline{l}$ par symbole de la source initiale satisfait : \[H(X) \leq \overline{l} \leq H(X)+1 \]
+
+L'inconvénient est la taille de la table de Huffmann à gérer.
+
+\newpage
+\subsection{Codage arithmétique}
+
+On considère une source binaire $X$ avec $p_0=Pr(X=0)$ et $p_i=Pr(X=i)$.
+
+Cette source génère un message $x_{1:N}$ de longueur $N$.
+
+
+On va associer un code $\underline{c}(x_{1:N})$ à $x_{1:N}$ qui sera un nombre dans l'intervalle $[0,1[$.
+
+On essaie de représenter $\c(x_{1:N})$ avec peu de bits si $x_{1:N}$ est très probable et avec plus de bits si $x_{1:N}$ est moins probable.
+
+\subsubsection{Algorithme de codage arithmétique (codage d'Elias)}
+
+\paragraph{Initialisation} $l_0=0, \quad h_1 = 1,\quad n=1$
+
+\paragraph{Étapes}
+\begin{enumerate}
+\item Si $x_n=0$ alors $l_n=l_{n-1}$ et $h_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$
+\item Si $x_n=1$ alors $l_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$ et $h_n=h_{n-1}$
+\item $n = n+1$
+\item Si $n\leq N$, aller en 1.
+\item On a $h_N-l_N=p(x_{1:N})$
+\end{enumerate}
+
+On pose $\mu(x_{1:N}) = \frac{l_N+h_N}{2} \text{ et } \lambda(x_{1:N}) = \lceil - \log_2(p(x_{1:N})) \rceil + 1$
+
+\[ \overline{c}(x_{1:N}) = \lfloor \mu(x_{1:N}) \rfloor _{\lambda(x_{1:N})} \]
+
+où $\lfloor a \rfloor _{\lambda}$ est la représentation binaire de $a$ tronquée à $\lambda$ bits. (Exemple : $\lfloor 0,1011 \rfloor _2 = 0,10$)\\
+
+Il faut montrer que $c(x_{1:N}) \in [l_N,h_N[$ (et qu'alors on pourra décoder), et que cette procédure de codage est efficace. \\
+
+
+
+\begin{itemize}
+\item On sait que $c(x_{1:N}) \leq \mu(x_{1:N})$ et on veut montrer que $\mu(x_{1:N})-c(x_{1:N}) \leq \frac{h_N-l_N}{2}$.\\
+
+Avec par exemple
+$\mu(x_{1:N}) = 0,101xxx$ et $c(x_{1:N})=0,101$, alors
+\[ \mu(x_{1:N}) - c(x_{1:N}) = 0,000xxx \leq \sum_{i=4}^6 2^{-i} \]
+
+
+Ainsi dans le cas général,
+\[ \mu(x_{1:N}) - c(x_{1:N}) \leq \sum_{i=\lambda(x_{1:N})+1}^{+\infty} 2 ^{-i} = 2^{-\lambda(x_{1:N})} \]
+
+Or, on a $\lambda(x_{1:N}) = -\lceil \log_2(p(x_{1:N})) \rceil + 1$
+\[
+\begin{array}{ccccc}
+- \log_2(p(x_{1:N})) + 1 & \leq & \lambda(x_{1:N}) & < & -\log_2(p(x_{1:N})) + 2 \\
+\log_2(p(x_{1:N})) - 1 & \geq & -\lambda(x_{1:N}) & > & \log_2(p(x_{1:N})) - 2 \\
+2^{\log_2(p(x_{1:N})) - 1} & \geq & 2^{-\lambda(x_{1:N})} & > & 2^{\log_2(p(x_{1:N})) - 2} \\
+\end{array}
+\]
+\[ \frac{p(x_{1:N})}{2} \geq 2^{-l(x_{1:N})} \]
+
+Ainsi, $\mu(x_{1:N}) - c(x_{1:N}) \leq 2^{-\lambda(x_{1:N})} \leq \frac{p(x_{1:N})}{2} = \frac{h_N-l_N}{2}$ donc  $c(x_{1:N}) \in [l_N,h_N[$ (donc on pourra décoder).
+
+\newpage
+\item L'efficacité du codage est montrée en calculant la longueur moyenne du code obtenu :
+\[ \overline{l} = \sum_{x_{1:N}\in\X^N} p(x_{1:N}) \lambda(x_{1:N}) \]
+
+En utilisant le premier encadrement de $\lambda(x_{1:N})$, alors
+\[ \begin{array}{ccccc}
+- \sum_{x_{1:N}} p(x_{1:N})( \log_2(p(x_{1:N}))-1) & \leq & \overline{l} & < & -\sum_{x_{1:N}} p(x_{1:N})(\log_2(p(x_{1:N}))-2) \\
+NH(X) + 1 & \leq & \overline{l} & < & NH(X) + 2
+\end{array}
+\]
+
+Cette procédure est efficace pour $N\to +\infty$, avec l'$\infty$ petit. Par exemple, pour $N=100$, alors la longueur moyenne sera proche à $1\%$ de l'entropie.
+\end{itemize}
+
+\paragraph{Décodage}
+On part de $c(x_{1:N})$, on réalise le découpage de $[0,1[$ suivant les probabilités d'apparition de 0 et de 1. À chaque étape, l'intervalle auquel appartient $c(x_{1:N})$ permet de déterminer le bit codé.\\
+
+\paragraph{Réalisation pratique}
+En pratique, le codage utilise l'intervalle $[0,2^p[$ où $p$ désigne la précision du codeur arithmétique. (pour le codage H264/AVC, on a $p=9$).
+
+On réalise des homothéties de centre 0, de rapport $2^p$ ou $2^{p-1}$ avec ou sans émission de bits.
+
+On estime les probabilités d'apparition des bits en parallèle du codage au codeur et au décodeur, et on modifie la façon de découper les intervalles en fonction de ces probabilités d'apparition estimées.
+
+On obtient alors un CABAC : Context Adaptative Binary Arithmetic Coder.
+
+\begin{rem}
+Si on a plusieurs symboles à coder (A,B,C), on pourrait faire un codeur arithmétique ternaire, mais on préfaire binariser les données (A=00,B=01,C=10) et utiliser un codeur arithmétique binaire, qui est plus pratique pour les remises à l'échelle.
+\end{rem}
+
+\newpage
+\subsection{Code de Lempel-Ziv-Welch}
+
+\paragraph{Idée}
+Avant l'algorithme arithmétique adaptatif, il fallait avoir les probabilités d'apparition des symboles (Huffmann, codage arithmétique,...). Le code LZW permet de faire une compression sans passer par la phase d'estimation des probabilités des symboles. Par exemple pour un texte, l'alphabet est gros, et le codeur arithmétique ne fonctionne pas très bien pour les gros alphabets, car il utilise d'abord une phase de binarisation.\\
+
+\subsubsection{Codage}
+Le codage de LZW est une variante des codes LZ77 et LZ78 qui utilise un dictionnaire et n'a pas besoin des probabilités de la source. C'est un cde universel.\\
+
+On considère une source $X$ à valeurs dans $\X=\{a,b,c\}$.
+
+\begin{enumerate}
+\item On initialise le dictionnaire de codage à l'aide des symboles de l'alphabet $\X$.
+\item On cherche la plus longue suite de symboles restant à coder et appartenant au dictionnaire et on la code.
+\item On rajoute cette suite suivi du premier symbole non codé $\omega$ au dictionnaire.
+\item Aller en 2 tant qu'il existe des symboles à coder.
+\end{enumerate}
+
+\begin{exemple}
+On a à coder la séquence $aabababca$.
+
+\begin{center}
+\begin{tabular}{|c|c|c|c|c|c|c|c|}
+\hline
+$a$ & $b$ & $c$ & $aa$ & $ab$ & $ba$ & $aba$ & $abac$ \\
+\hline
+0 & 1 & 2 & 3 & 4 & 5 & 6 & 7\\
+\hline
+\end{tabular}
+\end{center}
+
+On code $a$, on émet 0 et on ajoute $aa$ au dictionnaire.
+
+On code $a$, on émet 0 et on ajoute $ab$ au dictionnaire.
+
+On code $b$, on émet 1 et on ajoute $ba$ au dictionnaire.
+
+On code $ab$, on émet 4 et on ajoute $aba$ au dictionnaire.
+
+On code $aba$, on émet 6 et on ajoute $abac$ au dictionnaire.
+
+On code $c$, on émet 2.
+
+\end{exemple}
+
+\subsubsection{Décodage}
+Le décodage se fait
+\begin{enumerate}
+\item à partir du dictionnaire initial
+\item à chaque décodage d'un mot, on rajoute ce mot suivi de $\omega$ au dictionnaire
+\item $\omega$ n'est déterminé que si on a décodé le mot suivant
+\end{enumerate}
+
+\begin{exemple}
+On a à décoder 001462.\\
+
+On décode $a$, on ajoute $a\omega$ (3) au dictionnaire.
+
+On décode $a$, donc le (3) est $aa$ et on ajoute $a\omega$ (4) au dictionnaire.
+
+On décode $b$, donc le (4) était $ab$ et on ajoute $b\omega$ (5) au dictionnaire.
+
+On décode $ab$, donc le (5) était $ba$ et on ajoute $ab\omega$ (6) au dictionnaire.
+
+On décode $ab\omega$, qui était en fait un $aba$ et on ajoute $aba\omega$ (7) au dictionnaire.
+
+On décode $c$ donc le (7) était $abac$.
+\end{exemple}
+
+En pratique :
+\begin{itemize}
+\item les codes générés sont à nouveau codés à l'aide d'un code de Huffmann
+\item la taille du dictionnaire est limitée, les mots les moins utilisés sont effacés.
+\end{itemize}
+
+\end{document}

455-Codage_Sources/Cours/chap2.tex

@@ -0,0 +1,304 @@
+\documentclass[main.tex]{subfiles}
+
+\begin{document}
+\newcommand{\Y}{\mathcal{Y}}
+\newcommand{\X}{\mathcal{X}}
+\section{Introduction}
+L'objectif de la quantification est de représenter les réalisations d'une source à valeurs dans un "grand" alphabet $\X$ , par exemple $\mathbb{R}$, à l'aide d'éléments d'un alphabet plus "petit" $\Y \in\N $.\\
+
+Le quantificateur est donc défini par $q: \X \to \Y$. L'opération de quantification inverse, appelée aussi désindexation, est la fonction $q^{-1}: \Y \rightarrow \X$.\\
+
+Remarque: l'opération de quantification n'est pas réversible donc $q^{-1}$ n'a pas de réalité, par contre, par abus de langage on note : $Q(x) = q^{-1}(q(x))$.\\
+
+\begin{figure}[H]
+  \centering
+  \begin{tikzpicture}
+    \begin{axis}
+      [axis lines=middle,
+      xtick={-2,-1,1,2},
+      ytick={-1.5,0.5,1.5},
+      xlabel =$x$,ylabel=$Q(x)$,
+      ymin=-2,ymax=2
+      ]
+      \addplot+[no marks,color=black] plot coordinates {(-2,-1.5) (-1,-1.5) (-1,-0.5) (0,-0.5) (0,0.5) (1,0.5) (1,1.5)(2,1.5)};
+    \end{axis}
+  \end{tikzpicture}
+  \caption{Exemple de quantificateur}
+\end{figure}
+Un quantificateur est défini par des intervalles de quantification $b_0 < b_1 < ... < b_n$ et par des valeurs de reconstitution $y_1,...,y_n$ : si on a $x \in[b_{i-1} ; b_i[$ alors $Q(x) = y_i$.\\
+
+Dans la suite, on va voir comment régler de façon efficace les $b_i$ et les $y_i$.
+
+\newpage
+\section{Mesure de distorsion et distorsion}
+
+On introduit une mesure de distorsion pour les performances d'un quantificateur. Les principales mesures considérées sont:
+\begin{itemize}
+\item la mesure de distorsion en valeur absolue, $d(x,y) = |x-y|$
+\item la mesure de distorsion quadratique, $d(x,y) = (x-y)^2$
+\end{itemize}
+\bigbreak
+
+Pour une source $X$ décrite par une distribution de probabilité $f_X(x)$, la distorsion introduite par un quantificateur $Q(x)$, est la moyenne de la mesure de la distorsion:
+\[D = \int_{-\infty}^{\infty} d(x,Q(x))f_X(x) dx \]
+Pour la mesure de distorsion quadratique, on a:
+\[D = \int_{-\infty}^{\infty} (x-Q(x))^2f_X(x) dx \]
+
+\section{Quantification uniforme d'une source uniforme}
+
+On considère une source $X$ uniformément distribuée sur $[-X_{max} ; X_{max}]$. On considère aussi un quantificateur uniforme, c'est à dire que les intervalles de quantification sont tous de même taille, à M niveaux de sortie, situés au milieux des intervalles de quantification.
+Prenons par exemple, un quantificateur à 4 niveaux de quantification:
+%\img{0.5}{2/1/2.png}
+
+On note $\Delta$ l'intervalle de quantification, dans ce cas, $\Delta = \frac{2 X_{max}}{M}$.\\
+
+Pour déterminer la distorsion qui va être introduite par le quantificateur, on calcule simplement:
+\begin{align*}
+D &= \int_{-X_{max}}^{X_{max}}\frac{1}{2X_{max}}(x-Q(x))^2 dx
+\intertext{Comme $Q(x)$ est connu et constant sur un intervalle de quantification, on découpe simplement l'intervalle en sous-intervalles de quantification:}
+D &= \sum_{i=-M/2}^{(M-1)/2} \int_{i\Delta}^{(i+1)\Delta} \frac{1}{2X_{max}}(x-(i+\frac{1}{2})\Delta)^2 dx
+\intertext{On calcule}
+I & = \int_{i\Delta}^{(i+1)\Delta} (x-(i+\frac{1}{2})\Delta)^2  \frac{1}{2X_{max}} dx \\
+& = \int_{-\Delta/2}^{\Delta/2} \frac{u^2}{2X_{max}} du \\
+I & = \frac{\Delta^3}{24X_{max}} = \frac{X_{max}^2}{3M^3}
+\end{align*}
+Dans $D$, on a $M$ intégrales égales à $I$ donc \[ D = \frac{X_{max}^2}{3M^2}\]
+
+L'énergie de la source est mesurée par sa variance
+\begin{align*}
+\sigma^2 & = \int_{-\infty}^{+\infty} x^2 f(x) dx \\
+& = \int_{-X_{max}}^{X_{max}} \frac{x^2}{2X_{max}} dx \\
+\sigma^2 & = \frac{X_{max}^2}{3}
+\end{align*}
+
+On obtient donc $D = \frac{\sigma^2}{M^2}$. Sans codage entropique, le nombre de bits nécessaires pour représenter un niveau de reconstruction est $R = \lceil \log_2 M \rceil $, d'où
+\[ \boxed{ D = \sigma^2 2^{-2R} } \]
+
+La distorsion maximale est égale à l'énergie de la source, et diminue très rapidement quand on augmente le nombre de bits du quantificateur.
+
+\begin{rem}
+Dans certains cas (source non uniforme), un codage entropique peut permettre de réduire le débit.
+\end{rem}
+
+Rapport signal à bruit :
+\begin{align*}
+RSB & = \frac{\sigma^2}{D} = 2^{2R} \\
+RSB_{dB} & = 10\log_{10}(2^{2R}) = 6.02R \text{decibel}
+\end{align*}
+
+Le $RSB$ est utilisé comme mesure de qualité en audio, image...
+
+\newpage
+\section{Quantification uniforme d'une source quelconque}
+
+On considère une source $X$ décrite par sa ddp $f_X(x)$, quantifiée par un quantificateur uniforme à $M$ niveaux de pas $\Delta$.
+
+%\img{0.5}{2/1/3}
+
+Pour une source quelconque, il faut régler $\Delta$ de manière à équilibrer distorsion de granularité et distorsion de surcharge.
+
+\newpage
+\section{Quantification non-uniforme d'une source quelconque - Algorithme de Lloyd-Max}
+
+On considère une source $X$ discrète décrite par une ddp $f_X(x)$. On cherche le quantificateur non-uniforme à $M$ niveaux de sortie qui minimise la distorsion de quantification pour une norme de distorsion quadratique.\\
+
+Un tel quantificateur est caractérisé par
+\begin{itemize}
+\item $b_0 < b_1 < \dots < b_n$ les bornes des intervalles de quantification
+\item $y_1 < y_2 < \dots < y_n$ les valeurs de reconstruction
+\end{itemize}
+
+Ainsi, si $x \in [b_{i-1},b_i], Q(x) = y_i$.\\
+
+On cherche à minimiser la distorsion
+\[ D = \int_{-\infty}^{+\infty} (x-Q(x))^2f_X(x)dx = \sum_{i=1}^M \int_{b_{i-1}}^{b_i} (x-y_i)^2f_X(x)dx \]
+
+Les conditions nécessaires pour avoir $D$ minimale sont :
+\begin{itemize}
+\item $\derivp[D]{y_i} = 0, \forall i=1\dots M$
+\item $\derivp[D]{b_i} = 0, \forall i = 0\dots M$
+\end{itemize}
+
+\begin{align*}
+\intertext{1ère condition d'optimalité}
+\derivp[D]{y_i} & = \derivp{}{y_i} \int_{b_{i-1}}^{b_i} (x-y_i)^2 f_X(x) dx \\
+& = - 2 \int_{b_{i-1}}^{b_i} (x-y_i) f_X(x) dx
+\intertext{Ainsi,}
+\derivp[D]{y_i} = 0 & \Leftrightarrow \int_{b_{i-1}}^{b_i} xf_X(x)dx = y_i \int_{b_{i-1}}^{b_i} f_X(x)dx \\
+& \Rightarrow y_i = \frac{\int_{b_{i-1}}^{b_i} xf_X(x)dx}{\int_{b_{i-1}}^{b_i} f_X(x)dx}, \quad i = 1 \dots M
+\intertext{2ème condition d'optimalité}
+\derivp[D]{b_i} & = \derivp{}{b_i} \int_{b_i}^{b_{i+1}} (x-y_{i+1})^2f_X(x)dx + \derivp{}{b_i}\int_{b_{i-1}}^{b_i} (x-y_i)^2 f_X(x)dx \\
+& = -(b_i-y_{i+1})^2 f_X(b_i) + (b_i-y_i)^2 f_X(b_i)
+\intertext{Ainsi, }
+\derivp[D]{b_i} = 0 & \Leftrightarrow -(b_i-y_{i+1})^2 + (b_i-y_i)^2 = 0 \\
+& \Leftrightarrow (y_{i+1}-y_i)(b_i-y_{i+1}+b_i-y_i) = 0 \\
+& \Leftrightarrow b_i = \frac{y_i+y_{i+1}}{2}, \quad i=1 \dots M-1
+\end{align*}
+
+\newpage
+\subsection*{Algorithme de Lloyd -Max}
+\begin{enumerate}
+\item Initialisation : $b_0^{(0)} < b_1^{(0)} < \dots < b_n^{(0)}$ choisis arbitrairement, $k=1$.
+\item $y_i^{(k)}$ obtenus à partir des $b_i^{(k-1)}, i=0 \dots M$ en utilisant la 1ère condition d'optimalité
+\item $b_i^{(k)}$ obtenus à partir des $y_i^{(k)},i=1 \dots M$ en utilisant la 2ème condition d'optimalité
+\item $k=k+1$
+\item tant qu'il y a des variations des $y_i$ ou des $b_i$, aller en 2.
+\end{enumerate}
+
+\begin{rem}
+Essayer d'implémenter l'algorithme de Lloyd-Max à l'aide de Matlab, C ou Python pour les fétichistes. Pour Matlab, utiliser la fonction \texttt{quad} afin de calculer les intégrales. Prendre une ddp gaussienne.
+
+Essayer de retrouver ceci pour $M=4$ et $\sigma = 1$
+\begin{center}
+\begin{tabular}{ccc}
+$i$ & $b_i$ & $y_i$ \\ \hline
+1 & -0.98 & -1.51 \\
+2 & 0 & -0.45 \\
+3 & 0.98 & 0.45 \\
+4 & $+\infty$ & 1.51 \\
+\end{tabular}
+\end{center}
+
+Prendre l'infini égal à 10.
+\end{rem}
+
+\begin{rem}
+On ne quantifie jamais sur le domaine des pixels, car les ddp y sont immondes. On effectue des transformées, et ensuite les ddp sont sympa (gaussiennes, laplaciennes), ce qui permet d'avoir des algorithmes efficaces.
+
+La plupart du temps, les quantifications sont uniformes (JPEG, JPEG200, H264...). On n'utilise des quantifications non uniformes que dans le cas d'applications très précises, où le gain de 2 ou 3 dB sur le $RSB$ est vraiment nécessaire.
+\end{rem}
+
+\newpage
+\section{Comportement asymptotique}
+Pour étudier le comportement asymptotique d'un quantificateur, on suppose $M$ grand (les intervalles de quantification seront petits), $f_X(x) \approx f_X(y_i)$ sur $[b_{i-1},b_i]$. On note $\Delta_i = b_i - b_{i-1}$.\\
+
+On a \[P_i = Pr(X\in[b_{i-1},b_i]) \approx f_X(y_i)\Delta_i\]
+
+\begin{align*}
+D & = \sum_{i=1}^M \int_{b_{i-1}}^{b_i} (x-y_i)^2 f_X(x) dx \\
+D & = \sum_{i=1}^M f_X(y_i) \int_{b_{i-1}}^{b_i} (x-y_i)^2dx
+\intertext{On suppose que $y_i$ est au milieu de l'intervalle $[b_{i-1},b_i]$}
+\int_{b_{i-1}}^{b_i} (x-y_i)^2 dx & = \int_{-\Delta_i/2}^{\Delta_i/2} u^2 du = [\frac{u^3}{3}]_{-\Delta_i/2}^{\Delta_i/2} = \frac{2}{3} \frac{\Delta_i^2}{8} = \frac{\Delta_i^3}{12}
+\intertext{En réinjectant dans $D$, on a}
+D & = \sum_{i=1}^M f_X(y_i) \frac{\Delta_i^3}{12}
+\intertext{On pose $\alpha_i^3  = f_X(y_i)\Delta_i^3$}
+D & = \frac{1}{12} \sum_{i=1}^M \alpha_i^3
+\intertext{Si on calcule}
+\sum_{i=1}^M \alpha_i & = \sum_{i=1}^M (f_X(y_i))^{1/3} \Delta_i \approx \int_{-\infty}^{+\infty} (f_X(x))^{1/3} dx = cste
+\intertext{On doit trouver les $\Delta_i$ et les $\alpha_i$ qui minimisent $D$ sous la contrainte $\sum_{i=1}^M \alpha_i = C$. On introduit donc le Lagrangien du problème :}
+L(\alpha_1,\dots\alpha_M,\lambda) & = \frac{1}{12}\sum_{i=1}^M\alpha_i^3 + \lambda (\sum_{i=1}^M \alpha_i - C)
+\intertext{Condition d'optimalité :}
+\derivp[L]{\alpha_i} = 0 & \Rightarrow \frac{1}{4}\alpha_i^2 + \lambda = 0, \quad i = 1 \dots M \\
+& \Rightarrow \alpha_i^2 = -4\lambda
+\intertext{Les $\alpha_i$ sont donc tous égaux, d'où}
+\alpha_i & = \frac{1}{M} \int_{-\infty}^{+\infty} (f_X(x))^{1/3} dx
+\end{align*}
+\newpage
+On avait $\alpha_i^3 = f_X(y_i) \Delta_i^3$. Ainsi, si $f_X(y_i)$ est grand, $\Delta_i$ est petit, et inversement.
+
+%\img{0.5}{2/2/1}
+
+On peut donc calculer la distorsion :
+\begin{align*}
+D & = \frac{1}{12} \sum_{i=1}^M \frac{1}{M^3}(\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3 \\
+& = \frac{1}{12} (\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3.\frac{1}{M^2}
+\intertext{Or, $M=2^R$ d'où}
+D & = \frac{1}{12}(\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3.2^{-2R}
+\end{align*}
+
+\begin{rem}
+Comme pour la quantification uniforme, on a une décroissance en $2^{-2R}$ de la distorsion en fonction du débit. Ici, il y a un facteur multiplicatif qui dépend de la ddp de la source.
+
+Pour une source quelconque, le comportement débit / distorsion sera :
+\[ \boxed{ D(R) = \epsilon_X \sigma_X^2 2^{-2R} \text{ avec } \epsilon_X = \frac{1}{12\sigma_X^2}(\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3 } \]
+\end{rem}
+
+\section{Quantification vectorielle - Algorithme de Linde-Buzo-Gray}
+
+Avec une quantification vectorielle on considère des vecteurs de $N$ échantillons de la source que l'on va représenter à l'aide d'un index de quantification.
+
+%\img{0.5}{2/2/2}
+
+Pour un couple (poids, taille), on peut :
+\begin{itemize}
+\item quantifier indépendamment le poids et la taille avec deux quantificateurs scalaires
+\item les quantifier simultanément avec une quantification vectorielle
+\end{itemize}
+
+\subsection*{Algorithme de Linde-Buzo-Gray}
+
+\newcommand{\x}{\underline{x}}
+Cet algorithme permet de fabriquer une quantification vectorielle optimale (optimum local) pour un ensemble de $K$ points de $\R^N$ : $\x_1 \dots \x_K$ et quantifiés sur $M$ niveaux.
+
+\newcommand{\y}{\underline{y}}
+Pour cela, on introduit la mesure de distorsion $d(\x,\y) = \frac{1}{N}||\x-\y||^2$.
+
+Le quantificateur va minimiser la distorsion.\\
+
+Initialisation :
+\begin{itemize}
+\item On sélectionne $M$ points $\y_1^{(0)},\dots,y_M^{(0)}$ parmi les $\x_1,\dots,\x_K$ au hasard.
+\item $l=0, D_l = + \infty$
+\end{itemize}
+
+\begin{enumerate}
+\item On réalise une quantification de $\x_1,\dots,\x_K$ en se servant de $\y_1^{(l)},\dots,\y_M^{(l)}$.
+\[ q(\x_i) = \y_j \text{ ssi } ||\x_i-\y_j^{(l)}||^2 \leq ||\x_i-\y_k^{(l)}||^2, \quad \forall k\neq j\]
+
+\newcommand{\Cc}{\mathcal{C}}
+
+On obtient une partition de l'espace en cellules de quantification $\Cc_j^{(l)},j=1,\dots,M$ appelées cellules de Voronoï.
+
+%\img{0.5}{2/3/1}
+
+\item On calcule la distorsion :
+\[ D^{(l+1)} = \frac{1}{K} \sum_{i=1}^K ||\x_i-q(\x_i)||^2 \]
+
+\item Actualisation des valeurs de reconstruction. On considère l'ensemble des points appartenant à \[\Cc_j^{(l)} = \{ \x_1^{(l)},\dots, \x_{K_l}^{(l)} \}, \quad j = 1,\dots,M\]
+
+On calcule le barycentre des points de $\Cc_j^{(l)}$ qui constitue la nouvelle valeur de reconstruction.
+
+\[\y_j^{(l+1)} = \frac{1}{K_l} \sum_{i=1}^{K_l} \x_i^{(l)} \]
+
+\item $l=l+1$
+
+\item Aller en 1 tant que $D^{l-1} - D^l > \epsilon$
+
+\end{enumerate}
+
+L'algorithme LBG converge vers une minimum local de la distorsion.
+
+\newcommand{\Cc}{\mathcal{C}}
+En pratique :
+\begin{itemize}
+\item on transmet pour chaque $\x_i$ l'index $j$ de la cellule de Voronoi  $\Cc_j$ auquel il appartient.
+\item il faut transmettre au récepteur l'ensemble des points de reconstruction $\y_1^{(\overline{l})},\dots,\y_M^{(\overline{l})}$ où $\overline{l}$ est l'index final des itérations.
+\item la phase de réglage du quantificateur peut se faire sur seulement $L<<K$ points si on a beaucoup de points.
+\end{itemize}
+
+\newpage
+\section{Quantification scalable}
+
+L'objectif est de permettre une flexibilité en terme de compression débit-distorsion. Une possibilité est d'avoir recours à un quantificateur scalable.\\
+
+On considère une source uniforme sur $[-X_{max};X_{max}]$ quantifiée sur 8 niveaux.
+
+%\img{0.5}{2/3/2}
+
+Si on a $K$ échantillons à quantifier, on obtient $3K$ bits.\\
+
+Les $K$ bits de poids fort sont placés dans un premier paquet.
+
+Les $K$ bits de poids intermédiaire sont placés dans un second paquet.
+
+Les $K$ bits de poids faible sont placés dans un troisième paquet.\\
+
+Des utilisateurs disposant d'un mauvais canal recevront le premier paquet : la distorsion sera élevée.
+
+Des utilisateurs disposant d'un excellent canal recevront les 3 paquets et auront une distorsion faible.\\
+
+\begin{rem}
+Cette méthode permet de réaliser une quantification sans avoir à connaître l'état du canal.
+\end{rem}
+
+\end{document}

455-Codage_Sources/Cours/chap3.tex

@@ -0,0 +1,174 @@
+\documentclass[main.tex]{subfiles}
+
+\begin{document}
+
+L'idée du codage prédictif est d'utiliser les corrélations (ressemblances) temporelles ou spatiales du signal à compresser.
+
+\section{Rappels sur la corrélation}
+
+On considère une source $X$ qui émet un signal constitué de $x_1,\dots,x_N$ considérés comme une réalisation d'une suite de variables aléatoires $X_1,\dots,X_N$ de moyenne nulle.
+
+%\img{0.5}{3/1/1}
+
+La fonction de corrélation permet de mesurer la ressemblance entre échantillons voisins :
+\[ \gamma_x(n,k) = E(X_nX_{n+k}) \]
+
+Pour un signal stationnaire (dont les caractéristiques statistiques n'évoluent pas au cours du temps :
+\[ \gamma_x(n,k) = \gamma_x(k) = E(X_nX_{n+k}), \forall n\]
+
+En pratique, on estime la corrélation à partir des échantillons du signal à compresser.
+
+Estimateur biaisé :
+\[ \hat{\gamma_x}(k) = \frac{1}{N}\sum_{i=1}^{N-k} x_i x_{i+k}, \forall k \geq 0 \]
+
+\[ \gamma_x(k) = \frac{1}{N} \sum_{i=-k}^N x_i x_{i+k}, \forall k \leq 0 \]
+
+Avec Matlab, on l'obtient avec :
+\begin{lstlisting}
+[c,k] = xcorr(x,'biased');
+plot(k,c); grid;
+\end{lstlisting}
+
+$\gamma_x(k)$ est maximale en 0 et est égale à l'énergie $\sigma^2$ du signal.
+
+\newpage
+\section{Prédicteur optimal à 1 pas}
+
+On souhaite prédire la valeur de $X_n$ à partir de la valeur de $X_{n-1}$.
+
+Le prédicteur sera linéaire :
+\[\hat{X_n} = a_1 X_{n-1} \]
+
+On cherche la valeur de $a_1$ qui minimise $e = E((X_n-\hat{X_n})^2)$
+
+\begin{align*}
+e & = E((X_n-a_1X_{n-1})^2) \\
+& = E(X_n^2 -a_1^2 X_{n-1}^2 - 2a_1X_{n-1}X_n) \\
+& = E(X_n^2) + a_1^2E(X_{n-1}^2) - 2a_1E(X_{n-1}X_n)\\
+e & = \gamma_x(0) + a_1^2 \gamma_x(0) - 2a_1 \gamma_x(1)  \text{ par stationnarité}\\
+\derivp[e]{a_1}|_{\hat{a_1}} = 0 & \Leftrightarrow 2 \hat{a_1} \gamma_x(0) - 2 \gamma_x(1) = 0\\
+& \Rightarrow \hat{a_1} = \frac{\gamma_x(1)}{\gamma_x(0)}
+\end{align*}
+
+\begin{rem}
+Lorsque le signal sera très corrélé, $\gamma_x(1) \approx \gamma_x(0)$ et $\hat{a_1} \approx 1$. Pour un signal peu corrélé, $\gamma_x(1) \approx 0$ et $\hat{a_1} \approx 0$.
+\end{rem}
+
+Pour la valeur de $\hat{a_1}$ obtenue, on a
+\begin{align*}
+\hat{e} & = \gamma_x(0) + (\frac{\gamma_x(1)}{\gamma_x(0)})^2 \gamma_x(0) - 2 \frac{\gamma_x(1)^2}{\gamma_x(0)} \\
+& = \frac{\gamma_x(0)^2-\gamma_x(1)^2}{\gamma_x(0)} \leq \gamma_x(0)
+\end{align*}
+
+$\hat{e}$ est l'énergie de la partie qui n'a pas pu être prédite de $x_1,\dots,x_N$.\\
+
+Le résidu de prédiction a une variance plus faible. Si on le quantifie, il permettra de reconstituer le signal initial avec une distorsion plus faible.
+
+\newpage
+\section{Prédiction à $p$ pas}
+
+On cherche à prédire $X_n$ à partir des échantillons précédents $X_{n-1},\dots,X_{n-p}$.
+
+\newcommand{\ap}{\underline{a}}
+\newcommand{\Xn}{\underline{X_n}}
+\newcommand{\cp}{\underline{c}}
+\newcommand{\Rp}{\underline{\underline{R}}}
+
+\[ \hat{X_n} = a_1 X_{n-1} + \dots + a_pX_{n-p} = \ap^T \Xn \quad \text{ avec} \ap^T=(a_1\dots a_p) \text{ et } \Xn^T = (X_{n-1} \dots X_{n-p})\]
+
+On cherche $\ap$ minimisant
+\begin{align*}
+e & = E((X_n-\hat{X_n})^2) \\
+& = E((X_n-\ap^T\Xn)^2) \\
+& = E(X_n^2) + \ap^T E(\Xn\Xn^T) \ap -2\ap^t E(X_n\Xn) \\
+\text{Or, } E(X_n\Xn)& =(E(X_nX_{n-1}),\dots,E(X_nX_{n-p}))^T \\
+& = (\gamma_x(1), \gamma_x(2),\dots,\gamma_x(p))^T = \cp \\
+\text{De plus, } E(\Xn\Xn^T) & =
+\left[
+\begin{array}{cccc}
+E(X_{n-1}X_{n-1}) &E(X_{n-1}X_{n-2}) & \dots & E(X_{n-1}X_{n-p}) \\
+E(X_{n-2}X_{n-1}) & \ddots & & \vdots \\
+\vdots & & \ddots & \vdots \\
+E(X_{n-p}X_{n-1}) & \dots & \dots & E(X_{n-p}X_{n-p})
+\end{array}
+\right] \\
+& =
+\left[
+\begin{array}{cccc}
+\gamma_x(0) & \gamma_x(1) & \dots & \gamma_x(p-1) \\
+\gamma_x(1) & \gamma_x(0) & & \vdots \\
+\vdots & & \ddots & \gamma_x(1) \\
+\gamma_x(p-1) & \dots & \gamma_x(1) & \gamma_x(0)
+\end{array}
+\right] = \Rp\\
+\text{ donc } e & = \gamma_x(0) + \ap^T \Rp \ap - 2 \ap^T \cp
+\end{align*}
+
+\[ \left.\derivp[e]{\ap}\right|_{\hat{\ap}} =  0  \quad \Leftrightarrow \quad \underline{0} + 2 \Rp\hat{\ap} - 2\cp = 0  \quad \Rightarrow \quad \hat{\ap} = \Rp^{-1} \cp \]
+
+Pour cette valeur de $\hat{\ap}$, on a
+\begin{align*}
+\hat{e} & = \gamma_x(0) + \cp^T \Rp^{-1} \Rp \Rp^{-1} \cp -2\cp^T\Rp^{-1}\cp \\
+& = \gamma_x(0) - \cp^T \Rp^{-1} \cp \leq \gamma_x(0)
+\end{align*}
+
+Ce prédicteur à $p$ pas est en général plus efficace que le prédicteur à 1 pas mais il est plus complexe.
+
+\newpage
+\section{Mise en oeuvre du prédicteur}
+
+On considère le codeur prédictif de structure suivante à l'émetteur :
+%\img{0.4}{3/2/1}
+
+et de structure suivante au décodeur de récepteur:
+%\img{0.4}{3/2/2}
+
+On met en œuvre un dispositif de prédiction exploitant les échantillons disponibles au récepteur, de manière à éviter l'accumulation des erreurs de quantification. Il n'y a pas d'accumulation d'erreur de prédiction car le prédicteur est le même à l'émetteur et au récepteur.\\
+
+Pour le réglage du prédicteur, on distingue plusieurs méthodes :
+
+\begin{enumerate}\setlength{\itemsep}{5mm}
+\item On calcule $\hat{\gamma_x}$ sur tout le signal et on transmet $\underline{\hat{a}}_{opt}$.
+
+Avantage :
+\begin{itemize}
+\item sa simplicité de mise ne œuvre
+\end{itemize}
+Inconvénients :
+\begin{itemize}
+\item il ne permet pas de tenir compte des non stationnarités
+\item on règle le prédicteur à partir de $x_n$ et non de $\hat{x_n}$.
+\end{itemize}
+
+\item On découpe le signal en blocs et on recalcule le prédicteur sur chaque bloc.
+
+Avantages :
+\begin{itemize}
+\item sa simplicité de mise ne œuvre
+\item permet de s'adapter aux non-stationnarités
+\end{itemize}
+Inconvénient :
+\begin{itemize}
+\item débit nécessaire à la transmission des $\underline{\hat{a}}_{opt}$.
+\end{itemize}
+
+\item Mettre en place un prédicteur adaptatif. On travaille sur une fenêtre glissante contenant les N échantillons décalés : $\underline{\hat{X}}_n = (\hat{x}_{n-1}, ..., \hat{x}_{n-N})^T$.
+
+On calcule $\underline{\hat{a}}_{opt}$ à partir de $\underline{\hat{X}}_n$ (au codeur et au décodeur). On applique $\underline{\hat{a}}_{opt}$ pour coder et décoder $x_n$ en $\hat{x}_n$. À l'itération suivante, on calcule $\underline{\hat{a}}_{opt}$ à partir de $\underline{\hat{X}}_{n+1} = (\hat{x}_{n}, ..., \hat{x}_{n-N+1})^T$.
+
+Avantages :
+\begin{itemize}
+\item Il est très adaptatif.
+\item On ne transmet plus $\underline{\hat{a}}_{opt}$
+\end{itemize}
+
+Inconvénient :
+\begin{itemize}
+\item et bien... c'est pas simple.
+\end{itemize}
+
+
+\end{enumerate}
+
+
+\end{document}

455-Codage_Sources/Cours/cours0.tex

@@ -0,0 +1,98 @@
+\documentclass{../../cours.cls}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{Cours 0 : Introduction - Motivation}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+\renewcommand{\thesection}{\Roman{section}}
+
+
+
+\begin{document}
+
+\titre{\nom}
+
+\paragraph{Pourquoi a-t-on besoin du codage de source ?}
+
+Un téléviseur HD affiche des images de 1920 x 1080 pixels. Chaque pixel est formé d'une combinaison de 3 couleurs RGB, chacune des couleurs étant codée par un nombre sur 8, 10 ou 12 bits. À raison de 25, 50 ou 60 images par seconde, le débit nécessaire est R= 1920 x 1080 x 3 x 8 x 25 = 1,22 Gbits par seconde. \\
+
+En 4G, le débit maximal est de 100 Mbits par seconde (quand on est seul dans la zone) et en ADSL, il est de 20 Mbits par seconde.
+
+Il faut compresser les données avec un facteur 100 au minimum.\\
+
+\emph{"Le taux minimum c'est 25 images par seconde, pour pas avoir l'impression de regarder un dessin animé japonais."}
+\emph{"Des émissions mettent volontairement moins pour qu'on ait l'impression d'avoir trop bu en regardant la télé."}\\
+
+\paragraph{Comment faire de la compression?} Quelles propriétés du signal vidéo peut-on utiliser pour réaliser de la compression?
+On utilise la redondance statistique. Par exemple, pour la vision (ou tech 3D) on utilise les petites différences pour obtenir la profondeur. De la même façon, en stéréo on a deux micros pour l'enregistrement. C'est la ressemblance entre les deux signaux qui nous intéresse ici pour effectuer la compression.\\
+
+La compression est possible à cause de plusieurs propriétés:
+\begin{itemize}
+\item La corrélation temporelle (ressemblance entre deux image successives d'une vidéo ou échantillons audio successifs).
+\item La corrélation spatiale (le fait que certaines zones présentes sont relativement uniforme, ressemblance entre deux pixels voisins).
+\item La corrélation spectrale (ressemblance entre les composantes R, G et B d'une image).
+\item Les propriétés statistiques du signal (un texte contient plus de "e" que de "z" en général).
+\end{itemize}
+
+\paragraph{Exemple d'une chaîne de compression vidéo}
+On considère une vidéo mono-vue (pas en 3D) codée en niveaux de gris.\\
+
+\underline{Transformation}: On applique une transformation à l'image, c'est à dire que l'on cherche à exprimer les blocs de l'image dans une base autre que la base canonique, pour permettre une compression plus facile.\\
+Par exemple :
+
+$\begin{pmatrix}1&1\\1&1\end{pmatrix}$ permet de décrire les zones constantes
+
+$\begin{pmatrix}1&1\\-1&-1\end{pmatrix}$ pour décrire les variations verticales, et
+
+$\begin{pmatrix}1&-1\\1&-1\end{pmatrix}$ pour une variation horizontale.\\
+
+\underline{Quantification}: Elle permet de représenter les pixels transformés sur un nombre limité de bits (et d'en mettre plein à 0). Cette opération est irréversible.\\
+
+\underline{Codeur entropique}: Il exploite la redondance statistique des coefficients quantifiés (il prend les successions et les compresse). On ne peut pas encore envoyer les données sur le réseaux, il faut appliquer un standard de compression.\\
+
+\underline{Standard de compression}: Détermine la manière dont les bits en sortie sont organisés. (constitue les paquets, les numérote etc.)\\
+
+
+On peut alors transmettre l'image. Une fois récupérée, on applique un décodage entropique, puis un désindexation et enfin une transformation inverse.\\
+
+La désindexation permet d'obtenir à partir d'un coefficient quantifié, un nombre qui a la même dynamique qu'un coefficient transformé.(exemple: permet de retrouver un nombre à la bonne échelle, même si ce nombre n'est pas exactement le même).
+
+\imgt{0/1.png}
+\imgt{0/2.png}
+
+
+\paragraph{Comment transmettre une vidéo?} appliquer ce shcéma (JPEG) à chaque image et transmettre? non, trop lourd.
+On peut comparer l'image 2 à l'image précédente non pas 1 mais $\hat{1}$ l'estimée de l'image reçue par le récepteur, et l'on envoie la différence. Puis pour envoyer l'image 3, on estime la différence précédente, on y ajoute l'image estimée de la première image et on calcule la différence, que l'on envoie au travers des différentes transformations. Et ainsi de suite.\\
+
+De ce fait, au niveau du récepteur on mémorise l'image précédente à laquelle on ajoute les différences.\\
+
+Cette structure de codeur était celle des premiers codeurs vidéo (H261, MPEPZ). H265 encore utilisé a aussi cette structure.\\
+
+\noindent Notations :\\
+$I_n$: image numéro n\\
+$\hat{I_n}$ : image numéro n au décodeur\\
+$f(\hat{I_n}) = \tilde{I_{n+1}}$: image n+1 prédite\\
+
+
+On va étudier deux cas :
+\begin{enumerate}
+\item pas de décodeur au niveau du codeur mais on a un prédicteur.
+\begin{align*}
+\tilde{I_{n+1}} &= T^{-1}(Q^{-1}(Q(T(I_{n+1} - f(I_n))))) + \tilde{I_{n+1}}\\
+&= I_{n+1} - f(I_n) + E_{n+1} + \tilde{I_{n+1}} \text{	avec, E le bruit}
+\end{align*}
+$f(I_n)$ et $\tilde{I_{n+1}}$ ne se compensent pas totalement.
+\bigbreak
+
+\item On fait la prédiction a partir des images codées précédemment.
+\begin{align*}
+\tilde{I_{n+1}} &= T^{-1}(Q^{-1}(Q(T(I_{n+1} - f(\hat{I_n}))))) + f(\hat{I_n}\\
+&= I_{n+1} - f(\hat{I_n}) + E_n +f(\hat{I_n})\\
+&= I_{n+1} + E_n
+\end{align*}
+L'utilisation d'un décodeur au niveau du codeur (décodeur local) permet d'éviter une accumulation des erreurs au niveau des images décodées.
+\end{enumerate}
+
+\imgt{0/3.png}
+
+\end{document}

455-Codage_Sources/Cours/lol.m

@@ -0,0 +1,10 @@
+clear all
+close all
+
+M=20;
+Delta = 0.1;
+
+x = -5:0.01:5;
+
+[y,idx] = quantif(x,M,Delta);
+plot(x,y); grid; axis([-5 5 -5 5])

455-Codage_Sources/Cours/main.tex

@@ -0,0 +1,39 @@
+\documentclass{../../cours}
+\usepackage{../../raccourcis}
+% Mise en page
+\title{Notes de Cours}
+\author{Pierre-Antoine Comby}
+\teacher{Michel Kieffer}
+\module{455}
+\usepackage{listings}
+\definecolor{mygreen}{RGB}{28,172,0} % color values Red, Green, Blue
+\definecolor{mylilas}{RGB}{170,55,241}
+\begin{document}
+\lstset{language=Matlab, %
+% basicstyle=\color{red},
+    breaklines=true,%
+    morekeywords={matlab2tikz},
+    keywordstyle=\color{blue},%
+    morekeywords=[2]{1}, keywordstyle=[2]{\color{black}},
+    identifierstyle=\color{black},%
+    stringstyle=\color{mylilas},
+    commentstyle=\color{mygreen},%
+    showstringspaces=false,%without this there will be a symbol in the places where there is a space
+    numbers=left,%
+    numberstyle={\tiny \color{black}},% size of the numbers
+    numbersep=9pt, % this defines how far the numbers are from the text
+    emph=[1]{for,end,break},emphstyle=[1]\color{red}, %some words to emphasise
+    %emph=[2]{word1,word2}, emphstyle=[2]{style},
+}
+\maketitle
+\tableofcontents
+\chapter{Rappel de probabilité}
+\chapter{Introduction - Motivation}
+\subfile{chap0.tex}
+\chapter{Codage entropique (sans pertes)}
+\subfile{chap1.tex}
+\chapter{Quantification}
+\subfile{chap2.tex}
+\chapter{Codage prédictif}
+\subfile{chap3.tex}
+\end{document}

455-Codage_Sources/Cours/quantif.m

@@ -0,0 +1,8 @@
+function [y,idx] = quantif(x,M,Delta)
+
+idx = floor(x/Delta);
+
+idx = max(idx,-M/2);
+idx = min(idx,M/2-1);
+
+y = idx*Delta + Delta/2;

455-Codage_Sources/TD/TD1/TD1.tex

@@ -0,0 +1,241 @@
+\documentclass{article}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{TD1 : Codage de Sources}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+
+
+\begin{document}
+
+\titre{\nom}
+
+\begin{center}
+TD et TP : remi.azouit@ens-cachan.fr
+\end{center}
+
+\section*{Point de cours sur le codage de Huffman}
+
+Il s'agit d'un codage préfixe construit de façon récursive. Avec un codage préfixe, on n'a pas besoin de recevoir tout pour décoder. On peut décoder au fur et à mesure de la réception. Dans un code préfixe, chaque code ne peut pas être le début d'un autre code.
+
+\begin{exemple}
+
+On considère une source $X$ à valeurs dans $\X=\{A,B,...G\}$. 
+
+On a $p_A=3/8,\quad p_B=3/16, \quad p_C=3/16, \quad p_D=1/8,\quad p_E=1/16,\quad p_F=1/32,\quad p_G=1/32$.\\
+
+Pour construire le codage, on range les symboles par probabilité d'apparition décroissante et on construit un arbre en associant à chaque fois les deux probabilités les plus faibles. Ainsi, les symboles les plus probables ont les codes les plus courts. Si on a deux probabilités qui sont égales, on peut choisir de façon équivalente l'une des deux : le codage sera différent mais tout aussi efficace.
+
+\begin{figure}[h!]
+\centering
+\includegraphics[scale=0.5]{arbre1.png}
+\end{figure}
+
+\begin{center}
+\begin{tabular}{|c|c|c|c|c|c|c|c|}
+\hline 
+$X$ & A & B & C & D & E & F & G \\ 
+\hline 
+Code & 1 & 011 & 010 & 001 & 0001 & 00001 & 00000 \\ 
+\hline 
+\end{tabular} 
+\end{center}
+
+\begin{rmq}
+Pour coder un texte, on peut soit utiliser des probabilités et donc des codes "généraux", ou alors les recalculer à chaque fois.
+\end{rmq}
+\end{exemple}
+
+\newpage
+\section*{Exercice 1 : Codage de Huffman}
+
+\begin{enumerate}
+\item Construction de l'arbre puis codage
+
+\begin{figure}[h!]
+\centering
+\includegraphics[scale=0.5]{arbre2.png}
+\end{figure}
+
+\begin{center}
+\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
+\hline 
+X & D & B & A & F & E & C & G & H \\ 
+\hline 
+Code & 00 & 10 & 010 & 110 & 111 & 0110 & 01110 & 01111 \\ 
+\hline 
+\end{tabular} 
+\end{center}
+
+\item $R = \sum_{x\in\X}p_x \times l_x$ où $l_x$ est la longueur du code associé à $x$
+
+Ainsi, $R=2.83$ bits/symbole.
+
+\item L'entropie est le nombre minimal de bits par symbole nécessaire pour représenter la source: 
+
+$H=-\sum_{x\in\X} p_x \log_2 p_x$
+
+Ainsi $H=2.7978$ bits/symbole.\\
+
+On a bien $H \leq R$. Notre codage n'est pas le codage optimal.
+
+\begin{rmq}
+On obtiendrait $R=H$ dans le cas où toutes les probabilités étaient des puissances de 2.
+\end{rmq}
+
+\item Le code correspondant à $ABAADE$ est :
+$010|10|010|010|00|111$
+\end{enumerate}
+
+\newpage
+\section*{Exercice 2 : Codage d'une source de Markov}
+
+\begin{enumerate}
+\item Le nombre minimal de bits par symbole est déterminé par l'entropie. Le code le plus efficace aurait donc un nombre moyen de bits par symbole égal à l'entropie $H=\sum p_i \log(\frac{1}{p_i}) = 1.19$ bits/symbole.
+
+\item Construction de l'arbre puis du codage
+
+\begin{figure}[h!]
+\centering
+\includegraphics[scale=0.5]{arbre3.png}
+\end{figure}
+
+\begin{center}
+\begin{tabular}{|c|c|c|c|c|}
+\hline 
+X & ADD & STO & SUB & MPY \\ 
+\hline 
+\hline
+CODE & 0 & 10 & 110 & 111 \\ 
+\hline 
+\end{tabular} 
+\bigbreak
+\end{center}
+On calcule alors le débit moyen R = $\sum_{x \in \X} pr(x).Nbbit(X)$ = 1.375 bit/symbole\\
+
+On a une valeur supérieure à l'entropie mais inférieure à la valeur initiale. Cool! Notre codage n'est pas optimal mais est meilleur que le premier proposé.\\
+
+
+On considère maintenant le modèle de Markov d'ordre 1 pour modéliser la succession d'instructions constituany un programme. La matrice de transmission de ce modèle est donnée par:
+\[P_{j|i} = \begin{pmatrix}
+\frac{13}{16}&\frac{1}{16}&\frac{1}{16}&\frac{1}{16}\\
+0&0&0&1\\
+\frac{1}{4}&\frac{1}{4}&\frac{1}{4}&\frac{1}{4}&\\
+1&0&0&0
+\end{pmatrix}\]
+\begin{enumerate}
+\item Montrer que $p = \left(\frac{3}{4}\frac{1}{16},\frac{1}{16}, \frac{1}{8} \right)$ représente bien la distribution de probabilité stationnaire de la source de Markov d'ordre 1.\\
+Il s'agit de vérifier que $p\times P_{j|i} = p$.\\
+
+\underline{Remarque}:  On peut aussi voir ce résultat sous la forme plus courante $p^T = P_{j|i}^T p^T$. Ceci permet notamment de calculer $p$ s'il n'est pas donné, en cherchant un vecteur propre de $P_{j|i}^T$.\\
+
+\item Calculer les probabilités moyennes d'avoir une succession des deux instructions suivantes :\\
+
+\underline{Remarque}: ne pas confondre les lignes et les colonnes dans $P_{j|i}$:
+\[P_{j|i} = \begin{pmatrix}
+p_{ADD|ADD} & p_{SUB|ADD} & p_{MPY|ADD} & p_{STO|ADD}\\
+p_{ADD|SUB} & p_{SUB|SUB} & p_{MPY|SUB} & \vdots \\
+\vdots & \dots & \dots & \vdots\\
+p_{ADD|STO} & \dots & \dots & p_{STO|STO}
+\end{pmatrix}\]
+On a donc avec la règle de Bayes :
+\begin{align*}
+p(STO - ADD) &= p(ADD_j | STO_{j-1}).p(STO_{j-1})\\
+&= 1 \times \frac{1}{8}\\
+&= \frac{1}{8}\\
+p(ADD - ADD) &= \frac{13}{16}\times \frac{3}{4}\\
+&= \frac{39}{64}\\
+p(SUB-MPY) &= 0 \times \frac{1}{16}\\
+&= 0
+\end{align*}
+On peut calculer les autres probabilités cumulées de la même façon à partir des probabilités conditionnelles en les piochant dans le tableau.(Elles seront toutes données à la question 4.)\\
+
+\item En utilisant le modèle de Markov d'ordre 1, dans quelles proportions est-il possible de réduire le nombre moyen de bits utilisés pour coder une instruction?\\
+
+On calcule donc l'entropie $H=0.87$bit/symbole. On a une entropie inférieur à l'entropie initiale. Ceci vient du fait que l'on a un couplage des symboles, donc plus d'informations pour un même nombre de bits transmis.\\
+\end{enumerate}
+
+\item 
+On commence par rappeler toutes les probabilités cumulées ordonnées:\\
+\begin{center}
+\begin{tabular}{|c|c|c|c|c|c|}
+\hline 
+X & ADD-ADD & STO-ADD & SUB-STO & ADD-SUB & ADD-MPY \\ 
+\hline 
+Pr(X) & $\frac{39}{64}$ & $\frac{8}{64}$ & $\frac{4}{64}$ & $\frac{3}{64}$ & $\frac{3}{64}$ \\ 
+\hline 
+\hline
+X & ADD-STO & MPY-ADD & MPY-SUB & MPY-MPY & MPY-STO \\ 
+\hline 
+Pr(X) & $\frac{3}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ \\ 
+\hline 
+\end{tabular} 
+\end{center}
+\bigbreak
+On a alors $R = \frac{1.98}{2}$ bit/instruction. (On divise par 2 car on a 2 instructions codées à chaque fois)
+\end{enumerate}
+
+\newpage
+\section*{Exercice 14 : Codage de source distribué}
+
+\begin{enumerate}
+
+\item On a 8 possibilités et toutes équiprobables donc :
+\begin{align*}
+H(X) &= -\sum p_i log_2 p_i\\
+&= -8 (\frac{1}{8} log_2 \frac{1}{8})\\
+H(X) &= 3 bit/symbole =  H(Y)
+\end{align*}
+
+\item On a $d_H(x_k,y_k) \leq 1$ ce qui impose certaines combinaisons. Pour un x donné, il y a 4 possibilités de y. On a donc $8\times 4 =32$ possibilités toutes équiprobables.\\
+Ainsi, $H(x_k,y_k) = 5$ bit/symbole.\\
+
+\item On a par propriété : $H(X,Y) = H(X|Y) + H(Y)$, or si X et Y sont indépendants alors $H(X|Y) = H(X)$ donc on a $H(X|Y) = H(X) + H(Y)$.\\
+Comme on n'a pas cette égalité, c'est que X et Y sont corrélés.\\
+
+\item Il faut 3 bits pour coder $x_k$\\
+%Trou du cul!!!
+\item $H(X,Y) = H(X|Y) + H(Y)$ donc on a clairement $H(X|Y)=2$.\\
+
+Comme $d_H(x_k,y_k) \leq 1$, on a qu'un seul bite de différent. Il suffit donc de coder la position du bite différent, 00 si identique, 01 pour le premier etc.\\
+
+\item Pour coder le couple, il ne faut plus que 5 bits.\\
+
+\item Dans ce cas, s'ils ne communiquent pas, on va devoir coder avec 6 bits.\\
+
+\item 4 ensembles, donc on n'a besoin que de deux bits.\\
+
+\item On a donc besoin que de 5 bits.\\
+
+\item On connaît x et l'index de y, et x a un bit de différent avec l'une des deux possibilités de l'ensemble correspondant à l'index donné par y. Ces 2 possibilités sont distantes de 3, donc x ne peut être distant de 1 qu'avec l'un des deux. On peut donc retrouver (seulement car $d_H(x,y)\leq 1$) y à partir de x.\\
+
+\item  On alors R=H !!! \huge youuuupiiiiiiiiii \small
+\end{enumerate}
+
+\newpage
+\section*{Exercice 13 : Codage par plages de zéros}
+\begin{enumerate}
+\item On calcule l'entropie de cette source: $H(X) = -(p log(p) + (1-p)log(1-p))$\\
+
+\item Huffman serait inefficace (inutile) car il y a seulement 2 symboles à coder.\\
+
+\item On a $y \in [0;+\infty [$.\\
+
+\item On a $P_0 = p$, $P_1 = p(1-p)$, $P_2 = p(1-p)^2$ et $P_k = p(1-p)^k$.\\
+
+\item On a $H(Y) = -\sum_{k=0}^{\infty} P_k logP_k$.\\
+
+\item \begin{align*}
+H(Y) &= - \sum_{k=0}^{\infty}p(1-p)^klog(p(1-p)^k)\\
+&= - \sum_{k=0}^{\infty}p(1-p)^k(log(p)+klog(1-p))\\
+&= -log(p) - \frac{1-p}{p} log(1-p)
+\end{align*}
+
+\item On part de $-log(p_k) \leq \lceil-log(p_k) \rceil \leq -log(p_k) + 1$ en multipliant par $p_k$ et n sommant sur l'infini, on identifie l'entropie et on obtient: 
+\[H(Y) \leq l(Y) \leq H(Y) +1 \]
+
+\item k pour Y représente k+1 bits pour X.
+\end{enumerate}
+
+
+\end{document}

455-Codage_Sources/TD/TD2/TD2.tex

@@ -0,0 +1,91 @@
+\documentclass{article}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{TD2 : Random TD}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+
+
+\begin{document}
+
+\titre{\nom}
+
+\cacededi{Tu vois E.? Il a renversé sa bière sur le Mac Book de B. Alors B. était vénère. Du coup il lui a sucé la bite.}{Cédric Colonna}
+
+\section*{Exercice 3 : Code préfixe pour les entiers}
+
+\begin{enumerate}\setlength{\itemsep}{1cm}
+\item Si $\forall k,k \leq m$, alors il faut $\lceil \log_2 k \rceil$ ($\log_2 k$ arrondi au supérieur). Les codes sont ici tous de la même longueur, donc ce codage est préfixe.
+
+\item $\lceil \log_2 k \rceil$ donne la taille du nombre $k$ codé.
+
+\begin{center}
+\begin{tabular}{|c|c|c|}
+\hline
+$k$ & $\lceil \log_2 k \rceil$ & $C(k)$ \\
+\hline
+0 & 0 & 10 \\
+\hline
+1 & 0 & 11 \\
+\hline
+2 & 1 & 0110 \\
+\hline
+\end{tabular}
+\end{center}
+
+\item $ C_1(k)$ est-il préfixe ?
+
+On prend $k_1 \neq k_2$
+
+\begin{itemize}
+\item si $\lceil \log_2 k_1 \rceil = \lceil \log_2 k_2 \rceil$, alors la 2e partie du code est différente. Les deux codes font la même longueur mais sont différents, donc c'est préfixe.
+\item si $\lceil \log_2 k_1 \rceil < \lceil \log_2 k_2 \rceil$, alors la 1e partie du code est différente, donc c'est préfixe.
+\end{itemize}
+
+\item $l_1(k) = \lceil \log_2 k \rceil + 1 + \lceil \log_2 k \rceil = 2\lceil \log_2 k \rceil + 1 = 2 \log_2 k + \mathcal{O}(1)$
+
+\item On code $\lceil \log_2 k \rceil$ avec $C_1$ : $C_2(k) = C_1(\lceil \log_2 k \rceil)x...x$ où $x...x$ est $k$ en binaire.
+
+On a alors $l_2(k) = 2 \lceil \log_2 ( \lceil \log_2 k \rceil ) \rceil + \lceil\log_2 k \rceil = 2 \log_2 (\log_2 k) + \log_2 k + \mathcal{O}(1)$
+\end{enumerate}
+
+\section*{Exercice 5 : Distribution de redondance minimale}
+
+On considère un code préfixe : $C=\{C_1,C_J\}$ dont la longueur de chaque mot de code est $l_i, i = 1 \dots J$. 
+
+On considère une source $X$ dont l'alphabet est $A=\{a_1,...a_J\}$ et le vecteur de probabilités $\underline{p}=[p_1, \dots p_J]$.
+
+\newcommand{\p}{\underline{p}}
+
+\begin{enumerate}\setlength{\itemsep}{1cm}
+\item Donner l'entropie de la source .
+
+\[H(\p) = - \sum_{i=1}^J p_i \log_2 p_i\]
+
+\item Donner la longueur moyenne du code.
+
+\[l(C,\p) = \sum_{i=1}^J p_i l_i \]
+
+\item Donner la redondance du code
+\[ R(C,\p) = l(c,\p) - H(\p) = \sum_{i=1}^J p_i (l_i + \log_2 p_i) \]
+
+On veut chercher $\p$ qui va minimiser $R(c,\p)$
+
+\item Quelles sont les contraintes que doivent satisfaire les composantes de $\p$ ?
+\[ \sum_{i=1}^J p_i=1 \quad \et \quad \forall i=1,\dots J, \quad 0 \leq p_i \leq 1\]
+
+\item Un problème d'optimisation sous contraintes. Minimiser $R=\sum_{i=1}^J p_i (l_i + \log_2 p_i)$ 
+
+\item On utilise le lagrangien :
+\[ L(\p,\ld) = \sum_{i=1}^J p_i(l_i+\log_2 p_i) + \ld(\sum_{i=1}^J p_i-1) \]
+
+\item Condition d'optimalité :
+\begin{align*}
+\acc{\drond{L}{p_i}(\p^*,\ld^*)&=0, \quad \forall i = 1,\dots J}{\drond{L}{\ld}(\p^*,\ld^*)&=0} & \Leftrightarrow \acc{l_i + \log_2p_i^* + \log_2 e + \ld^* & = 0}{\sum_{i=1}^J p_i^*-1 & =0}\\
+& \Leftrightarrow \acc{p_i^* & = 2^{-l_i - \ld^* - \log_2 e} }{1 & = \sum_{i=1}^J 2^{-l_i}2^{-\ld^*-\log_2 e}} \\
+& \Leftrightarrow \acc{p_i^* & = 2^{-l_i}2^{- \ld^* - \log_2 e} }{2^{-\ld^*-\log_2 e} & = \frac{1}{\sum_{i=1}^J 2^{-l_i}}}
+\end{align*} 
+\[ \boxed{ p_i^*= \frac{2^{-l_i}}{\sum_{i=1}^J 2^{-l_i}}} \]
+\end{enumerate}
+
+\end{document}

455-Codage_Sources/TD/TD4/TD4.tex

@@ -0,0 +1,133 @@
+\documentclass{article}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{TDx : Choix de la fonction de Lyapunov candidate et Commandabilité et Observabilité}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+
+
+\begin{document}
+
+\titre{\nom}
+\section*{Exercice 9: Comparaison de LZM et de LZ77}
+
+On considère une source $\X$ ayant généré le message suivant:
+\[bongbonbongobang\$ \]
+ou $\$$ est un symbole particulier marquant la fin du message, mais qui devra être codé comme les autres symboles.\\
+
+\begin{enumerate}
+\item Trivial
+
+\item très simple
+
+\item easy
+
+\item On confond fréquence et probabilité estimé:
+\begin{tabular}{|c|c|}
+\hline 
+Symboles & Fréquence \\ 
+\hline
+\hline 
+b & $\frac{4}{17}$ \\ 
+\hline 
+o & $\frac{4}{17}$ \\ 
+\hline 
+n & $\frac{4}{17}$ \\ 
+\hline 
+g & $\frac{3}{17}$ \\ 
+\hline 
+a & $\frac{1}{17}$ \\ 
+\hline 
+$\$$ & $\frac{1}{17}$ \\ 
+\hline 
+\end{tabular} 
+
+L'entropie est donc de 2.4 bits/symbole.
+
+\item On initialise le dictionnaire avec 
+On commence par coder la première lettre, puis on rajoute la lettre et la lettre suivante au dictionnaire et ainsi de suite.
+Lorsque l'on arrive a $bo$ qui est déjà dans le dictionnaire, on peut directement le coder, puis on le rajoute ainsi que la lettre qui suit c'est à dire $bon$, et ainsi de suite.
+
+Le dictionnaire ainsi généré est:
+ 
+ \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|}
+   \hline 
+   a & b & g & o & n & $\$$ & bo & on & ng &gb & bon & nb & bong & go & ob & ba & an & ng$\$$\\ 
+   \hline 
+   0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 &9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17\\ 
+   \hline 
+   \end{tabular}   
+
+
+La séquence ainsi obtenue est :
+\[\text{1 4 3 2 6 3 10 0 4 1 0 8 5}\]
+
+\item Pour décoder, on effectue la même démarche, on décode 1 en d qui est déjà dans le dictionnaire et on ajoute d et la prochaine lettre trouvée et ainsi de suite. 
+Si on l'effectue correctement on retrouve le même texte avec le même dictionnaire.
+
+\item Il prend 5 symboles à partir de second. 
+
+\item Problème d'initialisation, il n'est pas possible de coder un symbole qui n'est jamais apparu.
+
+\item A l'itération i, on a $x_1,...,x_n = [y_i,\omega_i, \xi^{(i)},z_i]$ avec $y_i$ qui est déjà codé, $\omega_i$ la plus longue sous chaine de $y_i$ et $\xi^{(i)}$ le symbole suivant $\omega_i$.\\
+Ainsi $[\omega_i , \xi_{(i)}]$ est codé $ <j, k, \xi_{(i)}>$.\\
+Si $\omega_i = 0$ on code $ <0, 0, \xi_{(i)}>$.
+
+ET on oublie pas : $c(i,:) = <j, k, \xi_{(i)}>$, c'est à dire: ??!?. Ça traine tout seul dans son coin du tableau.
+
+\item Pour coder la chaîne bongbonbongobang$\$$, on commence par coder les quatre premiers symboles, c'est à dire que l'on a:
+\[<0,0<b> <0,0,o> <0,0,n> <0,0,g>\]
+Puis on code les quatre suivant ensemble avec $<1,3,b>$ car la sous-chaine composé de $bon$ apparait déjà avant.\\
+Puis $ongo$ car la racine $ong$ existe déjà donc on a $<2,3,o>$.\\
+Ensuite on code $ba$ qui donne $<1,1,a>$.\\
+Et pour finir on code $ng\$$ qui donne $<3,2,\$>$.
+
+
+\item \begin{lstlisting}
+c; //vecteur de triples
+x  = []; // séquence décodée
+for i=1:length(c)
+	x = [x, x[c(i,1):c(i,1)+c(i,2)], c(i,3)]
+end
+\end{lstlisting}
+
+\item Pour coder la chaîne bongbonbongobang$\$$, on commence par coder les quatre premiers symboles, c'est à dire que l'on a:
+\[<0,0<b> <0,0,o> <0,0,n> <0,0,g>\]
+Puis on code les quatre suivant ensemble avec $<1,3,b>$ car la sous-chaine composé de $bon$ apparait déjà avant.\\
+Puis $ongo$ car la racine $ong$ existe déjà donc on a $<2,3,o>$.\\
+Ensuite on code $ba$ qui donne $<1,1,a>$.\\
+Et pour finir on code $ng\$$ qui donne $<3,2,\$>$.
+
+\item On effectue le même travail en décodant cette fois. Si on ne se trompe pas, on retombe sur la même chose.
+
+\item Avec la méthode C, pour coder bongbongbonbongobang$\$$ on obtient:
+$<0,0,b> ... <0,0,g> <1,7,b><2,3,o><1,1,a><3,2,\$>$
+Ce que l'on retient c'est que pour bongbon on a une répétition sur 7 symbole des 4 premiers, après il suffit d'appliquer bêtement l'énoncé.
+
+\item \begin{lstlisting}
+c; 
+x=[];
+for i=1:length(c)
+	for j = 1:c(i,2)
+		x = x[x,x[c(i,1+j-1)];
+	end
+end
+\end{lstlisting}
+
+LE problème est que ?  pas compris ce qu'il a dit.
+
+\item \begin{align*}
+0 \leq j \leq s \Rightarrow \lceillog_2 S \rceil \text{ bits} \\
+0 \leq k \leq s + t \Rightarrow \lceillog_2 (S+t) \rceil \text{ bits} \\
+u \Rightarrow \lceillog_2 u \rceil \text{ bits} \\
+\end{align*}
+
+
+
+
+
+\end{enumerate}
+
+
+
+\end{document}

455-Codage_Sources/TD/TD5/TD5.tex

@@ -0,0 +1,239 @@
+\documentclass{article}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{TD5 : Codage de sources}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+
+
+\begin{document}
+
+\titre{\nom}
+
+\cacededi{C'est pratique d'avoir un pantalon troué, je peux me gratter les couilles comme je veux.}{Tom Colinot}
+
+\section*{2. Quantification et codage entropique}
+
+\img{0.5}{1}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}
+
+\item On ne peut pas le dire directement parce que les couples $(R,D)$ n'ont ni $R$, ni $D$ connu pour QSU et QSNU.
+
+\item Sans codeur entropique, on ne se réfère qu'on premier tableau. Pour le même débit, on a toujours $RSB_{QSU} \leq RSB_{SQNU}$, donc la QSNU est meilleure.
+
+\item $D_{min} = \sigma^2 2^{-2R}$
+\img{0.5}{2}
+
+\[RSB_{max} = 10\log_{10} \frac{\sigma^2}{D_{min}} = 6.02R\]
+
+\[D(r) - D_{min}(R) = RSB_{max} - RSB(R) = 6R - RSB(R)\]
+
+Avec un codeur entropique parfait, on a $R=H$ et donc :
+
+\begin{center}
+\begin{tabular}{c|c|c}
+$\log_2 M$ &  QSU & QSNU \\
+\hline
+1 & 1.6 & 1.6 \\
+2 & 2.174 & 2.166 \\
+3 & 2.296 & 2.33 \\
+4 & 2.232 & 2.37 \\
+5 & 2.124 & 2.36 
+\end{tabular} 
+\end{center}
+
+\item C'est QSU + CE qui est meilleur.
+\end{enumerate}
+
+
+\section*{3. Codage scalable}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}
+
+\item
+\begin{enumerate}
+\item $M=2^R$ donc $\Delta = \frac{2X_{max}}{M} = \frac{2X_{max}}{2^R} = X_{max}2^{1-R}$
+
+\item $D = \frac{\Delta^2}{12} = \frac{(X_{max}2^{1-R})^2}{12} = X_{max}^2 \frac{1}{3} 2^{-2R} $
+
+\item $R=3 \Rightarrow M=8$
+\imgt{3}
+
+\item
+\begin{itemize}
+\item $X_1 = 0.9X_{max} \Rightarrow 111$
+\item $X_2 = -0.1X_{max} \Rightarrow 011$
+\item $X_3 = -0.6X_{max} \Rightarrow 001$
+\end{itemize}
+\end{enumerate}
+
+\item Le train binaire classique est 111 0111 001. Si les six bits de la fin sont perdus, on ne peut que  reconstruire $X_1$.
+
+\item 
+\begin{itemize}
+\item Scalable 1 : on code d'abord $X_1X_2X_3$ avec un bit par $X_i$, puis on la quantifiée avec 2 puis 3 bits. Au final, on code donc $X_1X_2X_3$ sur un train de 3+6+9=18 bits. Si on n'a que les 3 premiers 100, on peut reconstituer $X_1 = 0.5X_{max}$, $X_2=X_3=-0.5X_{max}$.
+\item Scalable 2 : on envoie les premiers bits de $X_1,X_2$ et $X_3$ à la suite, puis les deuxièmes bits, puis les troisièmes. Le train fait donc 9 bits.
+\end{itemize}
+
+\begin{figure}
+\centering
+\begin{tabular}{c|c|c|c|c}
+R & D & Non scalable & Scalable 1 & Scalable 2 \\ 
+\hline
+0 & $\sigma^2$ & 0 & 0 & 0\\
+1 & $\sigma^2 2^{-2}$ & 1 & 1 & 1 \\
+2 & $\sigma^2 2^{-4}$ & 2 & 1+2 & 2 \\
+3 & $\sigma^2 2^{-6}$ & 3 & 1+2+3 & 3 
+\end{tabular}
+\caption{Débit}
+\end{figure}
+
+\item Codage d'image, codage vidéo. \textit{Because why ? Because fuck you that's why.}
+
+\end{enumerate}
+
+\section*{1. Quantification scalaire uniforme}
+
+\imgt{4}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}
+
+\item \begin{align*}
+D & = E[(x-y)^2] \\
+& = \int_{-\infty}^{+\infty} p_X(x)(x_Q(x))^2dx \\
+& = \sum_{i=1}^N \int_{s_{i-1}}^{s_i} p_X(x)(x-y_i)^2 dx
+\end{align*}
+
+\item $N=2$
+\img{0.5}{5}
+$y_1 = -\frac{\Delta}{2}, \quad y_2 = \frac{\Delta}{2}$
+
+On cherche $\Delta$ qui minimise $D$ :
+\begin{align*}
+D & = \int_{-\infty}^0 p_X(x)(x+\frac{\Delta}{2})^2 dx + \int_0^{\infty}p_X(x)(x-\frac{\Delta}{2})^2 dx \\
+& = \int_{-\infty}^0 p_X(x)(x^2+\frac{\Delta^2}{4}+x\Delta) dx + \int_0^{\infty}p_X(x)(x^2+\frac{\Delta^2}{4}-x\Delta) dx \\
+& = \int_{-\infty}^{\infty} p_X(x)(x^2 + \frac{\Delta^2}{4}) dx + \Delta(\int_{-\infty}^0p_X(x)dx - \int_0^{\infty}p_X(x)dx)
+\intertext{Or, $\int_{-\infty}^0p_X(x)dx + \int_0^{\infty}p_X(x)dx = 0$ ($X$ de valeur moyenne nulle)}
+D & = \int_{-\infty}^{\infty} p_X(x)(x^2 + \frac{\Delta^2}{4}) dx + 2\Delta\int_0^{\infty}p_X(x)dx \\
+& = (\int_{-\infty}^{+\infty} p_X(x)dx)\frac{\Delta^2}{4} - (2\int_0^{\infty} xp_X(x)dx)\Delta + \int_{-\infty}^{+\infty} x^2p_X(x)dx \\
+& = \frac{\Delta^2}{4} - (2\int_0^{\infty} xp_X(x)dx)\Delta + \int_{-\infty}^{+\infty} x^2p_X(x)dx
+\end{align*}
+
+Ainsi, \[ \drond{D}{\Delta} = 0 \Rightarrow \frac{1}{4}2\Delta - 2\int_0^{\infty} xp_X(x)dx = 0 \Rightarrow \Delta = 4\int_0^{\infty} xp_X(x)dx \]
+
+\item On a maintenant $\acc{y_{i+1}-y_i & = \Delta}{y_{N/2}  = -\Delta / 2, & y_{N/2+1} = \Delta / 2}$
+
+De plus, $y_{N/2}-y_1 = \Delta(N/2-1)$ donc $y_1 = y_{N/2}-\Delta(N/2-1) = -\Delta(N/2-1/2)$
+
+$y_i = \Delta/2(-N+1)+(i-1)\Delta = (i-N/2-1/2)\Delta$
+
+$S_i=y_i+\Delta/2=\Delta(i-N/2)$
+
+\begin{align*}
+D & = \int_{-\infty}^{\Delta(1-N/2)}p_X(x)(x+\Delta(N/2-1/2))dx + \sum_{i=2}^{N-1} \int_{\Delta(i-1-N/2)}^{\Delta(i-N/2)} p_X(x)(x-\Delta(i-\frac{N+1}{2})^2)dx + \int_{\Delta(N/2-1)}^{\Delta(i-N/2)} p_X(x)(x-\Delta(N/2-1/2))dx
+\end{align*}
+Ensuite, on cherche $\Delta$ tel que $\drond{D}{\Delta}=0$ mais c'est relou donc on va pas le faire.
+
+\item \begin{enumerate}
+\item $ \Delta = \frac{2A}{4} = \frac{A}{2}$
+\item \img{0.5}{6}
+\item $D=\frac{\Delta^2}{12}=\frac{A^2}{3\times^{2R}}$
+\end{enumerate}
+
+\end{enumerate}
+
+\section*{4. Codage avec information adjacent au décodeur}
+\begin{enumerate}
+\item Un exemple de compression d'une sourceX en se servant d'une information adjacente supposée disponible au codeur et au décodeur:\\
+En codage vidéo, le codeur dispose de l'image n-1 (compressée et décompressée) pour coder l'image n.\\
+Le décodeur dispose également de l'image n-1.\\
+
+\item On fabrique $\tilde{X}$ à partir de X et de Y :
+\[\tilde{X} = X-Y\]
+Au décodeur, $\tilde{X}$ sera utilisé pour calculer $\hat{X}$ (l'estimé de X).\\
+
+\item On suppose que Y et donc Z suivent une loi normale de moyenne nulle et d'écart-type respectif $\sigma_Y$ et $\sigma_Z$.
+\begin{enumerate}
+\item \begin{align*}
+E(X) &= E(Y+Z) = E(Y) + E(Z) = 0\\
+\sigma_X^2 &= E((X-E(X))^2) = E(X^2) =E(Y^2 + Z^2 + 2YZ)\\
+&= E(Y^2) + 2E(Y)E(Z) +E(Z^2)\\
+&= \sigma_Y^2 + \sigma_Z^2
+\end{align*}
+
+\item On ne tient compte de Y ni au codeur, ni au décodeur, $\tilde{X} = X$ et $D_1(R) = \sigma_X^2 2^{-2R}$.\\
+
+\item Si on compresse $\tilde{X} = X-Y = Z$, alors $D_2(R) = \sigma_{\tilde{X}}^2 2^{-2R} = (\sigma_X^2 - \sigma_Y^2) 2^{-2R}$. Donc:
+\[D_2(R) \leq D_1(R)\]
+
+\end{enumerate}
+
+\item On n'utilise pas Y au codeur, donc à priori, les performances devraient être moins bonnes.
+
+\img{0.5}{7.png}
+
+Tout d'abord, X est quantifié à l'aide d'un quantificateur scalaire uniforme de pas $\Delta_1$, centré en 0. X appartient à un intervalle de quantification répété par un index $q_1$, cet intervalle est alors découpé en M sous-intervalle, $m \in \{0,1,...,M-1\}$.
+
+\item \[\Delta_1 = M\Delta_2 \Rightarrow \Delta_2 = \frac{\Delta_1}{M} \]
+
+\item Les m(s) sont équiprobables donc:
+\[H = \sum_{i=1}^{\Delta_2} \frac{1}{\Delta_2}log_2(\frac{1}{\frac{1}{\Delta_2}} = log_2(\Delta_2) \]
+
+C'est le nombre de bits nécessaire.\\
+
+Première méthode:\\
+On quantifie Y au décodeur avec $\Delta_1$:
+
+\img{0.5}{8.png}
+
+\item Il faut:
+\[\acc{k\Delta_1 - \frac{\Delta_1}{2} \leq Y \leq k\Delta_1 + \frac{\Delta_1}{2}}{k\Delta_1 - \frac{\Delta_1}{2} \leq X \leq k\Delta_1 + \frac{\Delta_1}{2}} \]
+
+\img{0.5}{9.png}
+On suppose que $Y = k \Delta_1$ donc, on a $k\Delta_1 - \frac{\Delta_1}{2} \leq k \Delta_1 + Z \leq k\Delta_1 + \frac{\Delta_1}{2}$. Ce qui implique que :
+\[-\frac{\Delta_1}{2} \leq Z \leq \frac{\Delta_1}{2}\]
+
+\item Lorsque Y est très proche de la limite de l'intervalle, on a une distorsion de l'ordre de $\Delta_1^2$, même lorsque $Z << Y$.
+
+\item Deuxième méthode: On découpe l'intervalle de largeur $\Delta_1$ en 0, en M sous-intervalle, et on sélectionne le milieu 0' du sous-intervalle indexé par m.
+Ensuite, Y est quantifié avec $\Delta_1$ mais centré en 0'.\\
+
+\img{0.5}{10.png}
+
+Première étape: on reconstruit $\hat{\omega}$ à partir de m et $-\frac{\Delta_1}{2} \leq \tilde{\omega} \leq \frac{\Delta_1}{2}$.\\
+Seconde étape: $Y \rightarrow \hat{Y}$\\
+\begin{align*}
+\hat{X} = \hat{Y + \hat{\omega}} \text{ et,} X = Y + Z\\
+\text{donc, } (\hat{X}-X) = (\hat{Y} - Y) + (\hat{\omega} - Z)\\
+(\hat{Y}-Y)^2 \leq \frac{\Delta_1^2}{4}
+\end{align*}
+
+Si $Z \in [-\frac{\Delta_1}{2}; \frac{\Delta_1}{2}]$ alors, $ (Z-\hat{\omega})^2 \leq \Delta_1^2$, sinon $(z-\hat{\omega})^2$ peut être large.
+
+\item $\Delta_1$ assez grand pour que $|Z| \leq \frac{\Delta_1}{2}$.\\
+D(R) augmente aussi et $(\hat{m}-m)$ augmente.
+
+\item Montrons que $Pr(|Z|> \frac{\Delta_1}{2}) = \sqrt{\frac{2}{\pi \sigma_Z^2}} \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_z^2}) dz$, dont la distribution de probabilité est:
+\img{0.5}{11.png}
+On peut aussi montrer que:
+\begin{align*}
+Pr(|Z|>\frac{\Delta_1}{2}) &= 2 Pr(Z > \frac{\Delta_1}{2})\\
+&= 2 \sqrt{\frac{1}{2\pi \sigma_Z^2}} \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_z^2}) dz
+\end{align*}
+
+On suppose que $ \Delta_2 << \Delta_1$, et $\Delta_2 << \sigma_Z$.\\
+On peut montrer que $|Z| \leq \frac{\Delta_2}{2} \Rightarrow D_1 = \frac{\Delta_2^2}{12}$ et que $|Z| > \frac{\Delta_2}{2} \Rightarrow D_2 = \Delta_2^2$.\\
+
+\begin{align*}
+D &= D_1 Pr(|Z| \leq \frac{\Delta_1}{2}) + D_2 Pr(|Z| > \frac{\Delta_1}{2})\\
+&= \frac{\Delta_2^2}{12} \int_{-\frac{\Delta_1}{2}}^{\frac{\Delta_1}{2}} \frac{1}{\sqrt{2\pi \sigma_Z^2}} exp(-\frac{z^2}{2\sigma_Z^2})dz + \Delta_1^2 \sqrt{\frac{2}{\pi \sigma_Z^2}} \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_Z^2})dz\\
+&= \sqrt{\frac{2}{pi \sigma_z^2}} \left(\frac{\Delta_2^2}{12} \int_{0}^{\frac{\Delta_1}{2}} exp(-\frac{z^2}{2\sigma_Z^2})dz + \Delta_1^2 \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_Z^2})dz\right)
+\end{align*}
+
+\item R est fixé donc M est fixé, et $\Delta_2 = \frac{\Delta_1}{M}$.
+
+On calcul $\frac{\partial D}{\partial \Delta_1}$ et par magie on trouve 0.
+
+\end{enumerate}
+\end{document}

455-Codage_Sources/TD/TD6/TD6.tex

@@ -0,0 +1,212 @@
+\documentclass{article}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{TD6 : Allocation optimale de bits}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+
+
+\begin{document}
+
+\titre{\nom}
+
+\cacededi{C'est bizarre, il a dit "reconnaissance de formes" et on l'a pas entendu jouir derrière.}{Tom Colinot}
+
+\section{Transformation unitaires, gain de codage}
+
+\subsection{Quantification sans transformation}
+
+\newcommand{\y}{\underline{y}}
+
+On considère une source $X$ dont les réalisations sont groupées en $N$ composantes considérées comme générées par une source vectorielle $Y$.
+
+\begin{center}
+\begin{tabular}{c|cc}
+$X_i$ & $x_1\dots x_N$ & $x_{N+1} \dots x_{2N}$ \\
+\hline
+$Y_i$ & $\y_1$ & $\y_2$
+\end{tabular}
+\end{center}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}
+\item On dispose de $NR$ bits par vecteur de $N$ composantes, donc on utilise $R$ bits par composante.
+
+\item $D_Y = \frac{1}{N} E(||\y_k-\tilde{\y_k}||^2) = D_X$.
+\end{enumerate}
+
+\subsection{Quantification après transformation}
+
+\newcommand{\tv}{\underline{t}}
+\newcommand{\Uu}{\underline{\underline{U}}}
+\newcommand{\Id}{\underline{\underline{I}}}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}\setcounter{enumi}{2}
+\item On fait une transformation sur $\y_k$ : 
+\[ \tv_k = \Uu^T \y_k \avec \Uu.\Uu^T = \Id_N\]
+
+\imgt{1}
+
+\begin{align*}
+D_T & = \frac{1}{N}E(||\tv_k - \tilde{\tv_k}||^2 ) \\
+& = \frac{1}{N} E(||\Uu^T \y_k - \Uu^T \tilde{\y_k}||^2) \\
+& = \frac{1}{N} E((\Uu^T(\y_k-\tilde{\y_k}))^T.(\Uu^T(\y_k-\tilde{\y_k}))) \\
+& = \frac{1}{N}E((\y_k - \tilde{y_k})^T \Uu.\Uu^T(\y_k - \tilde{y_k})) \\
+& = \frac{1}{N}E(||\y_k - \tilde{\y_k}||^2) \\
+& = D_Y
+\end{align*}
+
+\item \[NR = \sum_{l=1}^N R_l\]
+
+\item \[D_T = \frac{1}{N} \sum_{l=1}^N D_{t,l}(R_l) = \frac{1}{N} \sum_{i=1}^N \epsilon_{t,l}\sigma^1_{t,l} 2^{-2R_l} \]
+
+\item On peut jouer sur $R_i, \forall i= 1, \dots N$ pour minimiser $D_T$ sous la contrainte $\sum R_l = NR$.\\
+
+$D_T$ est une fonction convexe, donc la condition d'extremum est une condition de minimum.\\
+
+On utilise le lagrangien :
+\[ J(R_1, \dots, R_N, \ld) = \frac{1}{N} \sum_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2 2^{-2R_l} + \ld(\sum_{l=1}^N R_l - NR) \]
+
+\item Les conditions nécessaires pour minimiser $J(R_1, \dots, R_N, \ld)$ sont donc :
+\[ \acc{ \drond{J}{R_l} & = 0, \quad \forall l = 1, \dots, N }{ \drond{J}{\ld} & = 0, \quad \forall \ld \in \{\ld\} \quad \text{Lolilonche}} \]
+
+\item \begin{align*}
+\drond{J}{R_l} = 0 & \Leftrightarrow \frac{1}{N} \epsilon_{t,l} \sigma_{t,l}^2 (-2\ln2)2^{-2R_l} + \ld = 0 \\
+& \Leftrightarrow 2^{-2R_l} = \frac{N\ld}{\epsilon_{t,l} \sigma_{t,l}^2 (2\ln2)}, \quad \forall l = 1, \dots, N\\
+\drond{J}{\ld} = 0 & \Leftrightarrow \sum_{l=1}^N R_l = NR
+\intertext{On en déduit donc que}
+2^{-2\sum R_l} & = \prod_{l=1}^N \frac{N\ld}{\epsilon_{t,l} \sigma_{t,l}^2 (2\ln2)} \\
+2^{-2NR} & = \prod_{l=1}^N \frac{(N\ld/(2\ln2))}{\epsilon_{t,l} \sigma_{t,l}^2} \\
+2^{-2NR} & =  \frac{(N\ld/(2\ln2))^N}{\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2} \\
+(N\ld/(2\ln2)) & = 2^{-2R} (\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N} \\
+\ld & = \frac{2\ln2}{N}2^{-2R} (\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}
+\intertext{ Ainsi, en reprenant l'expression trouvée pour $2^{-2R_l}$}
+R_l & = -\frac{1}{2} \log_2 \frac{(N\ld/(2\ln2))}{\epsilon_{t,l} \sigma_{t,l}^2} \\
+& = \frac{1}{2} \log_2 \frac{\epsilon_{t,l} \sigma_{t,l}^2}{2^{-2R}(\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}} \\
+R_l & = R + \frac{1}{2} \log_2 \frac{\epsilon_{t,l} \sigma_{t,l}^2}{2^{-2R}(\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}}
+\end{align*}
+
+\item \begin{align*}
+D_{t,l}(R_l) & = \epsilon_{t,l} \sigma_{t,l}^2 2^{-2R_l} \\
+& = \epsilon_{t,l} \sigma_{t,l}^2 \frac{N\ld}{\epsilon_{t,l} \sigma_{t,l}^2 (2\ln2)} \\
+D_{t,l}(R_l)& = \frac{N\ld }{2\ln2} \quad  \text{constante}
+\end{align*}
+
+\item \begin{align*}
+D_T^* & = \frac{1}{N} \sum_{l=1}^N D_{t,l}(Rl) \\
+& = \frac{1}{N} N \frac{N\ld}{2\ln2} \\
+& = \frac{N\ld}{2\ln2} \\
+D_T^* & = 2^{-2R} (\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}
+\end{align*}
+
+\item \[ D = \frac{1}{N} \sum_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2 2^{-2R} \]
+
+\item \[G_T = \frac{\frac{1}{N}\sum_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2}{(\prod_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2)^{1/N}} \]
+\end{enumerate}
+
+\begin{flushright}
+Si tu n'as pas encore vomi c'est le moment, je te laisse un bout de page blanche.
+\end{flushright}
+
+\vspace{8cm}
+
+\subsection{Applications numériques}
+Le chinois a \emph{rage quit}.
+
+\newpage
+\section{Techniques de codage d'images}
+
+\subsection{Codage sans pertes}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}
+\item On estime d'abord les probabilités d'apparition :
+
+\begin{center}
+\begin{tabular}{c|c|c}
+Symbole & Nombre d’occurrences & Probabilité estimée \\
+\hline
+4 & 1 & 1/16 \\
+6 & 3 & 3/16 \\
+8 & 7 & 7/16 \\
+10 & 5 & 5/16
+\end{tabular}
+\end{center}
+
+L'estimation de l'entropie est donc :
+\[ \hat{H}  = -\sum_i p_i \log_2 p_i \approx 1.749 \text{bpp} \]
+
+\item Il n'est pas possible d'obtenir un débit de 0.5 bpp $< \hat{H}$.
+\end{enumerate}
+
+\subsection{Codage avec pertes - Quantification}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}\setcounter{enumi}{2}
+\item $E(X) = 4\frac{1}{16} + 6\frac{3}{16} + 8\frac{7}{16} + 10\frac{5}{16} = 8$
+
+$Var(X) = E((X-E(X))^2) = \dots = 3$
+
+\item $D(R) = \sigma_X^2 2^{-2R}$
+\img{0.5}{2}
+
+\item $RSB_{dB} \approx 6R$ donc $R=1 \text{bpp} \Rightarrow RSB_{dB} = 6dB$. Pour $R=0.5\text{bpp}$, on aurait $RSB_{dB}=3dB$.
+
+\item On choisit le quantificateur suivant :
+\img{0.5}{3}
+
+\[ \hat{X} = \acc{ \mu + \Delta & \si X \geq \mu }{ \mu - \Delta & \sinon} \]
+
+\begin{align*}
+D & = \int_{-\infty}^{+\infty} ( X-\hat{X})^2 f_X(x) dx \\
+& = 2 \int_{\mu}^{+\infty} (X-\mu-\Delta)^2 f_X(x) dx 
+\intertext{Changement de variables $z=x-\mu$}
+D & = 2\int_0^{+\infty} (z-\Delta)^2 f_Z(z) dz \quad \avec f_Z(z) = \frac{1}{\sqrt{2\pi\sigma_X^2}}\exp(-\frac{z)^2}{2\sigma_X^2}) \\
+D & = 2\int_0^{\infty} z^2 f_Z(z) dz + 2\Delta^2 \int_0^{\infty} f_Z(z)dz - 4 \Delta\int_0^{\infty} zf_Z(z)dz \\
+& = \sigma_X^2 + \Delta^2 - 4 \Delta\int_0^{\infty} zf_Z(z)dz
+\intertext{Or,}
+\int_0^{\infty} zf_Z(z)dz & = \int_0^{+\infty} \frac{1}{\sqrt{2\pi\sigma_X^2}}\exp(-\frac{z)^2}{2\sigma_X^2}) dz \\
+& = \frac{1}{2} \int_0^{\infty} \frac{1}{\sqrt{2\pi\sigma_X^2}}\exp(\frac{-y}{2\sigma_X^2}) dy \quad \avec y=z^2\\
+& = \frac{1}{2} \frac{2\sigma_X^2}{\sqrt{2\pi\sigma_X^2}} = \frac{1}{2} \sqrt{\frac{2\sigma_X^2}{\pi}}
+\intertext{Donc}
+D(\Delta) = \Delta^2 - 2\sqrt{\frac{2\sigma_X^2}{\pi}} \Delta + \sigma_X^2
+\end{align*}
+
+Ainsi,
+\begin{align*}
+\drond{D}{\Delta} = 0 & \Rightarrow \Delta^* = \sqrt{\frac{2\sigma_X^2}{\pi}} \approx 1.4 \\
+& \Rightarrow D^* = \frac{2\sigma_X^2}{\pi} - 2\frac{2\sigma_X^2}{\pi} + \sigma_X^2 = \sigma_X^2(1-\frac{2}{\pi})\\
+& \Rightarrow RSB^* = \frac{\sigma_X^2}{D^*} = \frac{1}{1-\frac{2}{\pi}} \approx 2.75
+& \Rightarrow RSB_{dB}^*  = 10\log_{10}2.75 \approx 4.396 \text{dB} < 6 \text{dB}
+\end{align*}
+
+\item Pour avoir $R=0.5$ bpp on doit utiliser un quantificateur vectoriel.
+\end{enumerate}
+
+\subsection{Codage avec perte - DPCM} 
+
+\newcommand{\Aa}{\underline{\underline{A}}}
+\newcommand{\A}{\underline{A}}
+
+\begin{enumerate}\setlength{\itemsep}{5mm}\setcounter{enumi}{7}
+\item \begin{align*}
+\Aa & = [ \A_1 \A_2 \A_3 \A_4 ] \\
+\A_l & = [\A_1^T \A_2^T \A_3^T \A_4^T] \\
+& = [6,4,6,8,6,8,10,8,8,10,10,8,10,8,10]
+\end{align*}
+
+\item Soit $E(y) = 0, \y=[y_1,\dots y_N]$
+
+$\hat{y_{i+1}} = \alpha y_i, \quad \alpha^* = \frac{\gamma_Y(1)}{\gamma_Y(0)}$
+
+$\underline{B}_L = \A_l - 8[ 1, 1, \dots 1 ] = [-2, -4, -2, \dots]$
+
+$\gamma_X(0) = \sigma_X^2 = 3$
+
+$\gamma_X(1) = \frac{1}{N} \sum_{i=1}^{N-1} B_l(i+1) B_L(i) = 5/4$
+
+$\alpha \approx 0.4$
+
+$\y(i) = \alpha B_L(i-1) + 8$
+
+La variance diminue un peu.
+\end{enumerate}
+
+\end{document}

455-Codage_Sources/TD/TD7/TD7.tex

@@ -0,0 +1,156 @@
+\documentclass{article}
+\input{../../preambule/preambule}
+
+\newcommand{\nom}{TD7}
+\renewcommand{\nomentete}{UE455 - \nom}
+
+
+
+\begin{document}
+
+\titre{\nom}
+\section*{Exercice I-TD3: Entropie différentielle d'une source Gaussienne}
+
+\begin{enumerate}
+\item 
+\begin{align*}
+f_X(x) = \frac{1}{\sqrt{2 \pi \sigma^2}} exp(-\frac{(x-\mu)^2}{2\sigma^2}
+\intertext{Montrons que $h(x) = \frac{1}{2} log_2(2\pi e \sigma^2)$}
+h(x) = - \int_{-\infty}^{\infty} f_x(x) log_2(f_x(x)) dx\\
+\end{align*}
+Tout réside dans le log de exp, la définition de la variance et de la densité de probabilité. Trivial donc.
+
+\item \begin{align*}
+\int_{-\infty}^{+\infty} f_Y(x) log_2(\frac{f_X(x)}{f_Y(x)}) dx = h(Y) - \int_{-\infty}^{+\infty} f_Y(x) log_2(f_X(x)) dx
+=h(Y) - h(X) \leq 0
+\end{align*}
+D'où le résultat.
+\end{enumerate}
+
+
+\section*{Exercice III-TD3: Schéma de compression binaire avec pertes}
+
+\begin{align*}
+\underline{X} = x_1x_2...x_mX_{m+1}x_{2m}\\
+\underline{Y} = y_1 y_2
+\end{align*}
+On suppose que $n_j = \sum_{i=0}^M x_{(j-1)M+i}$. $n_j$ est le nombre de '1' dans $x_{(j-1)M+i} ... x_{jM}$.
+
+\begin{align*}
+y_j &= \acc{0 \text{ si, } M-n_j > \frac{M}{2}}{1 \text{sinon, ie  } n_j \geq \frac{M}{2}}\\
+\text{Pour $M = 3$, alors } x_1 &= 001\text{ }000\text{ }100\text{ }110\\
+\text{On a donc: } y_1 = 0 0 0 1
+\end{align*}
+
+
+\begin{enumerate}
+\item \begin{align*}
+y_2 = (0100) \Rightarrow \hat{x_2} = 000\text{ }111\text{ }000\text{ }000
+\end{align*}
+
+\item On a $P(X=0) = 0.8$. Et $R = \frac{j}{Mj} = \frac{1}{M} $ bits/symbole.\\
+Pour M=2, y=0 si $n<\frac{M}{2}$ et 0 sinon, d'où:\\
+\begin{tabular}{|c|c|c|c|c|c|}
+\hline 
+$\underline{X}$ & p & n & y & $\hat{\underline{x}}$ & d \\ 
+\hline 
+\hline
+00 & $0.8^2$ & 0 & 0 & 00 & 0 \\ 
+\hline 
+01 & $0.8\times 0.2$ & 1 & 1 & 11 & 1 \\ 
+\hline 
+10 & $0.2 \times 0.8$ & 1 & 1 & 11 & 1 \\ 
+\hline 
+11 & $0.2^2$ & 2 & 1 & 11 & 0 \\ 
+\hline 
+\end{tabular}
+
+\begin{align*}
+d(x,\hat{x}) &= \sum x_i \oplus \hat{x_i}\\
+D_2 &= \frac{1}{2}(0*0.8^2+1*0.8*0.2+1*0.8*0.2+0)\\
+\end{align*}
+Pour $M=1$ on a $D_1 = 0$ et $R_1 = 1$ bits/symbole.\\
+Et l'autre qui demande à aller beaucoup plus vite...
+
+
+n=0,...,M
+$p_n  = C_M^n*0.2^n * 0.8^{m-n}$
+Si $n<\frac{M}{2}$ $\hat{x}$ contient M 0 et x N 1, donc $d_n = n$
+Si $n\geq \frac{M}{2} $ $\hat{x}$ contient M bits de 1 et X M-n bits de 0 donc $d_n = M-n$
+
+$D_n = \sum_{n=0}^{\lceil\frac{M}{2}\rceil - 1} C_M^n 0.2^n 0.8^{M-n} + \sum_{n = \lceil\frac{M}{2}}^{M} C_M^n 0.2^n 0.8^{M-N} (M-n) = \frac{1}{M}$
+
+\item 
+\begin{align*}
+x \longrightarrow y \longrightarrow Codeur \\
+1 \longrightarrow \frac{1}{M} \longrightarrow \frac{1}{M} H(Y) = R\\
+P(Y=0) = \sum_{n=0}^{\lceil\frac{M}{2}\rceil - 1}  C_M^n 0.8^{M-n} 0.2^n\\
+P(Y=1) = 1-P(Y=0)\\
+H(Y) = -P(Y=0)log_2(P(Y=0)) - P(Y=1) log_2(P(Y=1))
+\end{align*}
+\end{enumerate}
+
+
+\section*{Exercice I-TD4: Codage prédictif d'une image}
+
+\begin{align*}
+\underline{\underline{X}} = [\underline{\underline{X}}(:,1),\underline{\underline{X}}(:,2),...,\underline{\underline{X}}(:,256)]\\
+\underline{X_1} = \begin{pmatrix}
+\underline{\underline{X}}(:,1)\\
+\underline{\underline{X}}(:,2)\\
+\vdots\\
+\underline{\underline{X}}(:,256)
+\end{pmatrix}
+\end{align*}
+
+\begin{enumerate}
+\item L'hypothèse gaussienne est fausse, mais permet d'obtenir de bon ordre de grandeurs, $D(R) \leq D_g(R)$\\
+
+\item On a $D(R) = \sigma_x^2 * 2^{-2R}$ pour une source gaussienne.\\
+$RSAB_{db} = 10 log_10 \frac{\sigma_x^2}{\sigma_x^2 2^{-2R}} \approx 6R$\\
+$RSAB_{db} \geq 30 dB \Rightarrow R \geq 5$ bits/pixel.
+
+\item \begin{align*}
+\hat{x}(n) = [a_1 
+r = E(x(n)x_p(n) = \begin{pmatrix}
+\mu_x(1)\\
+\vdots
+\mu_x(p)
+\end{pmatrix}\\
+R = \begin{pmatrix}
+\mu_x(0) & &\\
+\vdots & \mu_x(|i-j|) & \\
+\mu_x(p) & & 
+\end{pmatrix}
+\end{align*}
+
+Des résultats random :\\
+Par définition : \\
+$\sigma_e^2 = (e^2(n))= E((x(n)-\hat{x(n)})^2)$
+Par minimisation de $\sigma_e^2$ donc en dérivant:
+$a_p = R^{-1} r$ puisque R est inversible.\\
+\begin{align*}
+\sigma_e^2 = \mu_x(0) - 2(R^{-1}r)^Tr + (R^{-1}r)^TR(R^{-1}r)\\
+=\mu_x(0) - r^TR^{-1}r
+\end{align*}
+
+\item L'écart entre deux pics est 256. Les ressemblances des pixels d'une même ligne qui sont séparés de 256 pixels dans $\hat{x}$. Les maximums décroissent.
+
+\item Pour p=1 r vaut $\mu_x(1)$ et $R = \mu_x(0)$, ainsi $a_p = 0.95$.
+Et $\sigma_e^2 = 255.95$.
+
+\item $D_e = \sigma_e^2 2^{-2R}$
+$RSBA_{db} = 10 log_{10} \frac{\sigma_x^2}{D_e} \approx10.4 + 6R = 30.$
+Donc R = 33 bits/symbole
+
+\item Gain de codage:
+$RSAB^{(p)} - RSAB = 10.4 db$
+
+
+
+\end{enumerate}
+
+
+
+
+\end{document}

455-Codage_Sources/TP/TP3/Manip1.m

@@ -0,0 +1,51 @@
+% Aymeric Arnould, Tom Colinot
+% TP3
+% Codage INTRA (1/3)
+
+clear all;
+file = fopen('Foreman.qcif','r');
+
+% Affichage d'une image de la séquence
+% [compY,compU,compV]=yuv_readimage(file,'qcif');
+% 
+% figure(1)
+% colormap(gray)
+% subplot(131); imagesc(compY); title('Y')
+% subplot(132); imagesc(compU'); title('U')
+% subplot(133); imagesc(compV'); title('V')
+
+
+% Codage d'une séquence d'image successives
+[compY,compU,compV]=yuv_readimage(file,'qcif');
+Y=zeros(size(compY,1),size(compY,2),5);
+Yc= zeros(size(compY,1),size(compY,2),5);
+PSNR=[];
+bpp=[];
+gamma = 1;
+
+for i=1:5
+    [compY,compU,compV]=yuv_readimage(file,'qcif');
+    [I_rec,b,r] = encodeINTRA(compY,gamma);
+    Y(:,:,i) = compY;
+    Yc(:,:,i) = I_rec;
+    PSNR(i)=b;
+    bpp(i) = r;
+end
+
+gamma
+mean(PSNR)
+mean(bpp)*size(compY,1)*size(compY,2)*15
+
+% Affichage des images de bases et des images codées de la séquence
+% figure(1)
+% colormap(gray)
+% for i=1:5
+%     subplot(1,5,i); imagesc(Y(:,:,i));
+% end
+% 
+% figure(2)
+% colormap(gray)
+% for i=1:5
+%     subplot(1,5,i); imagesc(Yc(:,:,i));
+% end
+   

455-Codage_Sources/TP/TP3/Manip2.m

@@ -0,0 +1,33 @@
+% Aymeric Arnould, Tom Colinot
+% TP3
+% Codage INTRA (2/3)
+% Question 7 - PSNR moyen en fonction du débit moyen
+
+%clear all;
+PSNRmoy=[];
+bpsmoy=[];
+gamma=1:10;
+
+
+for k=1:size(gamma,2)
+    g=gamma(k);
+    file = fopen('Foreman.qcif','r');
+
+    PSNR=[];
+    bpp=[];
+
+    for i=1:5
+        [compY,~,~]=yuv_readimage(file,'qcif');
+        [~,b,r] = encodeINTRA(compY,g);
+        PSNR(i)=b;
+        bpp(i) = r;
+    end
+
+    PSNRmoy(k)=mean(PSNR);
+    bpsmoy(k)=mean(bpp)*size(compY,1)*size(compY,2)*15;
+end
+
+figure(1)
+subplot(131); plot(gamma,PSNRmoy); xlabel('gamma'); ylabel('PSNR moyen');
+subplot(132); plot(gamma,bpsmoy); xlabel('gamma'); ylabel('Debit moyen (bps)');
+subplot(133); plot(bpsmoy,PSNRmoy); xlabel('Debit moyen (bps)'); ylabel('PSNR moyen');

455-Codage_Sources/TP/TP3/Manip3.m

@@ -0,0 +1,25 @@
+% Aymeric Arnould, Tom Colinot
+% TP3
+% Codage INTRA (3/3)
+% Question 8 - Qualité visuelle (INTRA) pour différentes valeurs du débit
+
+clear all;
+
+gamma=[0.1 1 3 5]; %Pas de quantification
+
+file = fopen('Foreman.qcif','r');
+[compY,~,~]=yuv_readimage(file,'qcif');
+    
+figure(1)
+subplot(2,length(gamma)+1,1); imagesc(compY); title('Image non compressee');
+
+colormap(gray)
+
+for k=1:size(gamma,2)
+    g=gamma(k);
+    [Yc,~,bpp] = encodeINTRA(compY,g);
+    d=bpp*size(compY,1)*size(compY,2)*15;
+    
+    subplot(2,length(gamma)+1,k+1); imagesc(Yc); title(strcat('gamma=',num2str(g),',','Debit=',num2str(d), 'bps'));
+    subplot(2,length(gamma)+1,length(gamma)+k+2); imagesc(compY-Yc);
+end

455-Codage_Sources/TP/TP3/Manip4.m

@@ -0,0 +1,44 @@
+% Aymeric Arnould, Tom Colinot
+% TP3
+% Codage INTER (1/3)
+% Questions 9 à 11
+
+clear all;
+
+n=5; %Nombre d'images à coder
+gamma=1; %Pas
+
+file = fopen('Foreman.qcif','r');
+
+[compY,~,~]=yuv_readimage(file,'qcif');
+Y=zeros(size(compY,1),size(compY,2),n); %images avant codage
+Yc= zeros(size(compY,1),size(compY,2),n); %images codées
+
+%Codage de la première image
+[I_rec,PSNR,bpp] = encodeINTRA(compY,gamma);
+Y(:,:,1) = compY;
+Yc(:,:,1) = I_rec; 
+
+%Pour les images suivantes, soustraction de l'image n-1 à l'image n avant
+%codage
+for k=2:n
+    [compY,~,~]=yuv_readimage(file,'qcif');
+    Yk = compY - Yc(:,:,k-1); % différences par rapport à l'image décodée précédente
+    [I_rec,PSNR,bpp] = encodeINTRA(Yk,gamma);
+    
+    Y(:,:,k) = Yk;
+    Yc(:,:,k) = I_rec + Yc(:,:,k-1); % reconstruction à l'aide de l'image décodée précédente
+end
+
+% Affichage des images de bases et des images codées de la séquence
+figure(1)
+colormap(gray)
+for i=1:n
+    subplot(1,n,i); imagesc(Y(:,:,i));
+end
+
+figure(2)
+colormap(gray)
+for i=1:n
+    subplot(1,n,i); imagesc(Yc(:,:,i));
+end

455-Codage_Sources/TP/TP3/Manip5.m

@@ -0,0 +1,52 @@
+% Aymeric Arnould, Tom Colinot
+% TP3
+% Codage INTER (2/3)
+% Questions 12
+
+%clear all;
+
+n=5; %Nombre d'images à coder
+gamma=1:10; %Pas
+
+PSNRmoy=[];
+bpsmoy=[];
+
+
+
+for i=1:length(gamma)
+    g = gamma(i);
+    
+    file = fopen('Foreman.qcif','r');
+    [compY,~,~]=yuv_readimage(file,'qcif');
+    PSNR_seq=[];
+    bpp_seq=[];
+
+    %Codage de la première image
+    [I_rec,PSNR,bpp] = encodeINTRA(compY,g);
+    Y(:,:,1) = compY;
+    Yc(:,:,1) = I_rec; 
+    PSNR_seq(1) = PSNR;
+    bpp_seq(1) = bpp;
+
+    %Pour les images suivantes, soustraction de l'image n-1 à l'image n avant
+    %codage
+    for k=2:n
+        [compY,~,~]=yuv_readimage(file,'qcif');
+        Yk = compY - Yc(:,:,k-1); % différences par rapport à l'image décodée précédente
+        [I_rec,PSNR,bpp] = encodeINTRA(Yk,g);
+
+        Y(:,:,k) = Yk;
+        Yc(:,:,k) = I_rec + Yc(:,:,k-1); % reconstruction à l'aide de l'image décodée précédente
+        PSNR_seq(k) = PSNR;
+        bpp_seq(k) = bpp;
+    end
+    
+    PSNRmoy(i) = mean(PSNR_seq);
+    bpsmoy(i) = mean(bpp_seq)*size(compY,1)*size(compY,2)*15;
+
+end
+
+figure(1);
+subplot(131); plot(gamma,PSNRmoy); xlabel('gamma'); ylabel('PSNR moyen');
+subplot(132); plot(gamma,bpsmoy); xlabel('gamma'); ylabel('Debit moyen (bps)');
+subplot(133); plot(bpsmoy,PSNRmoy); xlabel('Debit moyen (bps)'); ylabel('PSNR moyen');

455-Codage_Sources/TP/TP3/Manip6.m

@@ -0,0 +1,47 @@
+% Aymeric Arnould, Tom Colinot
+% TP3
+% Codage INTER (3/3)
+% Question 13 - Qualité visuelle (INTER) pour différentes valeurs du débit
+
+clear all;
+
+n=5;
+gamma=[0.1 1 3 5]; %Pas de quantification
+
+file = fopen('Foreman.qcif','r');
+
+[compY,~,~]=yuv_readimage(file,'qcif');
+Y=zeros(size(compY,1),size(compY,2),n); %images avant codage
+Yc= zeros(size(compY,1),size(compY,2),n); %images codées
+
+
+
+for i=1:size(gamma,2)
+    g=gamma(i);
+    
+    file = fopen('Foreman.qcif','r');
+    [compY,~,~]=yuv_readimage(file,'qcif');
+    %Codage de la première image
+    [I_rec,PSNR,bpp] = encodeINTRA(compY,g);
+    Y(:,:,1) = compY;
+    Yc(:,:,1) = I_rec;
+
+    figure(1)
+    colormap(gray)
+    
+
+    for k=2:n
+        [compY,~,~]=yuv_readimage(file,'qcif');
+        Yk = compY - Yc(:,:,k-1); % différences par rapport à l'image décodée précédente
+        [I_rec,PSNR,bpp] = encodeINTRA(Yk,g);
+
+        Y(:,:,k) = Yk;
+        Yc(:,:,k) = I_rec + Yc(:,:,k-1); % reconstruction à l'aide de l'image décodée précédente
+    end
+    
+    
+    d=bpp*size(compY,1)*size(compY,2)*15;
+    
+    subplot(1,length(gamma)+1,1); imagesc(compY); title('Image non compressee');
+    subplot(1,length(gamma)+1,i+1); imagesc(Yc(:,:,end)); title(strcat('gamma=',num2str(g),',','Debit=',num2str(d), 'bps'));
+end

455-Codage_Sources/TP/TP3/Manip7.m

@@ -0,0 +1,43 @@
+% Aymeric Arnould, Tom Colinot
+% TP3 
+% Compensation de mouvement (1/2)
+% Codage d'une séquence
+
+clear all
+
+n=5; %Nombre d'images à coder
+gamma=1;
+blksize = 16; %taille des blocs
+SearchRange = 8; %portée des vecteurs mouvements
+
+file = fopen('Foreman.qcif','r');
+
+[compY,~,~]=yuv_readimage(file,'qcif');
+Y= zeros(size(compY,1),size(compY,2),n); %images de base
+Yc= zeros(size(compY,1),size(compY,2),n); %images (dé)codées
+Yp= zeros(size(compY,1),size(compY,2),n); %images prédites
+
+%Codage de la première image
+[I_rec,PSNR,bpp] = encodeINTRA(compY,gamma);
+Y(:,:,1) = compY;
+Yc(:,:,1) = I_rec; 
+
+for k = 2:n
+    [compY,~,~]=yuv_readimage(file,'qcif');
+    Y(:,:,k) = compY;
+    compYr = Yc(:,:,k-1);
+    [compPred,~,~,~] = PicturePred(compY,compYr,blksize,SearchRange);
+    [I_rec,~,~] = encodeINTRA(compY-compPred,gamma);
+    
+    Yc(:,:,k) = compPred + I_rec;
+    Yp(:,:,k) = compPred;
+end
+
+% Affichage des images de bases et des images codées de la séquence
+figure(1)
+colormap(gray)
+for i=1:n
+    subplot(3,5,i); imagesc(Y(:,:,i));
+    subplot(3,5,i+n); imagesc(Yp(:,:,i));
+    subplot(3,5,i+2*n); imagesc(Y(:,:,i)-Yp(:,:,i));
+end

455-Codage_Sources/TP/TP3/Manip8.m

@@ -0,0 +1,58 @@
+% Aymeric Arnould, Tom Colinot
+% TP3 
+% Compensation de mouvement (2/2)
+% PSNR moyen et débit moyen
+
+%clear all
+
+n=5; %Nombre d'images à coder
+gamma=1:10;
+blksize = 16; %taille des blocs
+SearchRange = 8; %portée des vecteurs mouvements
+
+PSNRmoy=[];
+bpsmoy=[];
+bpsmoy2=[];
+
+for i=1:length(gamma)
+    g=gamma(i);
+    file = fopen('Foreman.qcif','r');
+    
+    PSNR_seq=[];
+    bpp_seq=[];
+    bppMV_seq=[];
+
+    [compY,~,~]=yuv_readimage(file,'qcif');
+    Yc= zeros(size(compY,1),size(compY,2),n); %images (dé)codées
+
+    %Codage de la première image
+    [I_rec,PSNR,bpp] = encodeINTRA(compY,g);
+    Yc(:,:,1) = I_rec; 
+    PSNR_seq(1) = PSNR;
+    bpp_seq(1) = bpp;
+
+    for k = 2:n
+        [compY,~,~]=yuv_readimage(file,'qcif');
+        compYr = Yc(:,:,k-1);
+        [compPred,~,~,bppMV] = PicturePred(compY,compYr,blksize,SearchRange);
+        [I_rec,~,bpp] = encodeINTRA(compY-compPred,g);
+
+        Yc(:,:,k) = compPred + I_rec;
+        
+        PSNR_seq(k) = PSNR;
+        bpp_seq(k) = bpp;
+        bppMV_seq(k-1) = bppMV;
+    end
+    
+    PSNRmoy(i) = mean(PSNR_seq);
+    bpsmoy(i) = mean(bpp_seq)*size(compY,1)*size(compY,2)*15; %en ne tenant pas compte de bppMV
+    bpsmoy2(i) = (mean(bppMV_seq)+mean(bpp_seq))*size(compY,1)*size(compY,2)*15; %en tenant compte de bppMV
+    
+    fclose('all');
+
+end
+
+figure(2);
+subplot(131); plot(gamma,PSNRmoy); xlabel('gamma'); ylabel('PSNR moyen');
+subplot(132); plot(gamma,bpsmoy,gamma,bpsmoy2); xlabel('gamma'); ylabel('Debit moyen (bps)'); legend('Sans bppMV','Avec bppMV');
+subplot(133); plot(bpsmoy,PSNRmoy,bpsmoy2,PSNRmoy); xlabel('Debit moyen (bps)'); ylabel('PSNR moyen'); legend('Sans bppMV','Avec bppMV');