From d29bb3a9d17ffc5144c4754da07b69b789c03f8e Mon Sep 17 00:00:00 2001
From: "iliya.saroukha" <iliya.saroukhanian@etu.hesge.ch>
Date: Fri, 18 Apr 2025 21:16:46 +0200
Subject: [PATCH] fix: typos
---
report/report.qmd | 23 ++++++++++++-----------
1 file changed, 12 insertions(+), 11 deletions(-)
diff --git a/report/report.qmd b/report/report.qmd
index 798dcc4..d7df196 100644
--- a/report/report.qmd
+++ b/report/report.qmd
@@ -87,8 +87,8 @@ def dct(padded_img: Img, kernel_size: int) -> Img:
La fonction `dct` va utiliser une _helper function_ (fonction d'aide) qui va
permettre de sélectionner une sous-section de l'image en fonction des indices
de départs fournis pour la ligne et la colonne. Cette fonction retournera
-le bloc 8x8 sur lequel la transformation sera appliqué puis insérer dans l'image
-résultante à la bonne position.
+le bloc 8x8 sur lequel la transformation sera appliquée puis insérée dans
+l'image résultante à la bonne position.
```python
def sliding_window(img: Img, x_pos: int, y_pos: int, n: int):
@@ -148,8 +148,8 @@ faire il nous est nécessaire de calculer en premier lieu la matrice de
quantification en fonction d'un facteur de qualité $q$ fourni. Plus ce facteur est
élevé, plus la dégradation de la qualité de l'image sera grande. Du fait que
nous travaillons toujours sur des blocs 8x8, la matrice de quantification
-$\mathbf{Q}$ possédera donc ces dimensions. La valeur de chaque entrée de cette
-matrice est calculée de la manière suivante :
+$\mathbf{Q}$ possédera donc les mêmes dimensions. La valeur de chaque entrée de
+cette matrice est calculée de la manière suivante :
$$
\mathbf{Q}_{ij} = 1 + q(i + j + 1)
@@ -170,16 +170,16 @@ def quantized(kernel_size: int, quality: int) -> Img:
```
Ayant obtenu cette matrice, il est à présent possible quantifier la DCT de
-l'image obtenue au préalable. Pour ce faire, nous allons à nouveau séléctionner
+l'image obtenue au préalable. Pour ce faire, nous allons à nouveau sélectionner
des sous-sections de taille 8x8 de la DCT et allons diviser ce bloc par la
matrice de quantification $\mathbf{Q}$. Du fait que nous travaillons avec des
tableaux `numpy`, il nous est possible de diviser un tableau par un autre du
fait que l'opérateur **`/`** est surchargé. En l'occurrence, celui-ci
effectuera une division entrée par entrée entre les deux matrices à partir du
-moment qu'elles possèdent les mêmes dimensions. Les résultats de division seront
-arrondis à l'entier le plus proche à travers la fonction `np.round`. La matrice
-résultante $\mathbf{Q}_{\text{DCT}}$ de cette opération encodera la dégradation
-supplémentaire ajoutée à la DCT.
+moment qu'elles possèdent les mêmes dimensions. Les résultats des divisions
+seront arrondis à l'entier le plus proche à travers la fonction `np.round`. La
+matrice résultante $\mathbf{Q}_{\text{DCT}}$ de cette opération encodera la
+dégradation supplémentaire ajoutée à la DCT.
```python
def quantize_dct(dct_img: Img, kernel_size: int, quality: int) -> Img:
@@ -236,7 +236,7 @@ Huffman Adaptatif. L'intérêt de cet algorithme est de pouvoir maximiser la
compression d'une chaîne de caractères en combinant le codage fixe (e.g. ASCII)
et variable (e.g. Huffman). L'arbre résultant aura deux types de noeuds
différents. Les noeuds dit **externes** représenteront les caractères rencontrés
-de la chaîne original et les des noeuds **internes** correspondront à la somme
+de la chaîne originale et les noeuds **internes** correspondront à la somme
des poids de ses enfants (i.e. nombre d'occurrence des caractères). Par
conséquent le poids de la racine de l'arbre doit être égal à la longueur de la
chaîne de caractère initiale.
@@ -268,8 +268,9 @@ $(k - r - 1)$ sur $e$ bits.
```python
def compute_k(char: str) -> int:
return DICT_ALPHABET[char]
+```
-
+```python
def compute_code(char: str):
e, r = compute_vitter_params(len(LIST_ALPHABET))
k_char = compute_k(char)
--
GitLab