diff --git a/Pixels/CompteRendu/2025_HasleyKazem_CompteRendu.pdf b/Pixels/CompteRendu/2025_HasleyKazem_CompteRendu.pdf
new file mode 100644
index 0000000..47f487b
Binary files /dev/null and b/Pixels/CompteRendu/2025_HasleyKazem_CompteRendu.pdf differ
diff --git a/Pixels/CompteRendu/2025_HasleyKazem_CompteRendu.tex b/Pixels/CompteRendu/2025_HasleyKazem_CompteRendu.tex
new file mode 100644
index 0000000..5f5a490
--- /dev/null
+++ b/Pixels/CompteRendu/2025_HasleyKazem_CompteRendu.tex
@@ -0,0 +1,169 @@
+\documentclass{article}
+
+\usepackage[tmargin=2cm,rmargin=1in,lmargin=1in,margin=0.85in,bmargin=2cm,footskip=.2in]{geometry}
+
+\usepackage[upright]{fourier} % PACKAGE QUI MODIFIE LA FONT DE BASE
+\usepackage[none]{hyphenat}
+\usepackage[utf8]{inputenc}
+\usepackage{tikz}
+\usepackage{tkz-tab}
+\usepackage{amsfonts}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage[mathscr]{eucal}
+\usepackage{bigints}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{pdfpages}
+\usepackage{centernot}
+\usepackage{witharrows}
+\usepackage[inline]{enumitem}
+\usepackage{cancel}
+\usepackage{hyperref}
+
+\usepackage{stmaryrd}
+
+\usepackage{fancyhdr}
+\usepackage{graphicx}
+
+\pagestyle{fancy}
+\fancyhf{}
+\fancyhead{}
+\fancyfoot[C]{\thepage}
+
+\renewcommand{\headrulewidth}{0.4pt}
+\renewcommand{\footrulewidth}{0.4pt}
+
+\title{\textbf{Compte-rendu Pixels}}
+\date{\textit{\today}}
+\author{Hasley William - 228}
+
+% Des commandes qui se font à chaque page --------
+\parindent 0ex
+
+
+\begin{document}
+
+\begin{titlepage}
+
+\begin{center}
+
+\vfill
+\line(1,0){400}\\
+\huge{\textbf{Pédagogie : Compte-rendu (PIXELS)}}\\[3mm]
+\Large{\textbf{- William HASLEY \& Nowar KAZEM - }}\\[1mm]
+\line(1,0){400}
+\vfill
+\end{center}
+
+
+\begin{flushleft}
+
+\renewcommand{\contentsname}{Sommaire} % Remplace Contents par Sommaire
+\tableofcontents
+\vfill
+\end{flushleft}
+
+\end{titlepage}
+
+\newpage
+
+\section{Présentation de l'activité}
+
+Nous avons choisi de présenter une activité similaire à l'activité "Blasons", mais avec un objectif différent. L'activité Pixels propose aux élèves de remplir des grilles de pixels via des instructions de base. Bien que l'activité d'origine choisit de présenter la représentation machine d'images (par compression de motifs répétitifs), nous avons choisi de parler d'aléa en informatique théorique. Le format de tableaux que propose l'activité nous a paru comme une représentation suffisamment visuelle de l'aléatoire pour pouvoir transmettre l'idée principale (qui sera détaillée dans la section \hyperref[sec:enjeu]{\textbf{\underline{Enjeu choisi}}} ).\\
+
+Nous avons choisi de produire un matériel réduit mais versatile : Les élèves ont reçu : \begin{itemize}
+\item Une grille (6x6) vide.
+\item Des pixels de chaque couleur
+\item Des tableaux à reproduire.
+\end{itemize}
+
+\bigskip
+
+Pour cette activité, nous avons choisi l'organisation suivante :
+\begin{enumerate}
+\item Présentation de Nous, puis "histoire" de l'activité.
+\item Première tâche : Par groupe de trois, essayer de reproduire des tableaux donnés via un jeu d'instruction réduit avec le moins d'instructions possibles (Un peintre dictant les instructions sans voir le tableau en construction, seulement l'objectif. Un robot reproduisant le tableau avec les pixels fourni. Un observateur vérifiant les coups du robot et pouvant aider le peintre si en difficulté).
+
+\item Regrouper les résultats (si le temps le permet). Il est intéressant de calibrer l'activité afin que tous les groupes ne réussissent pas à tout finir (pour faire jouer l'intuition plus tard dans l'activité).
+
+\item Faire une course au tableau (envoyer deux groupes de deux pour réaliser un tableau chaque). Les règles sont les mêmes que précédemment, mais les groupes doivent réaliser des tableaux différents: L'un est complètement aléatoire, et l'autre plus ordonné. Demander au reste de la classe de réfléchir à des solutions pour les deux tableaux. (Pour ne pas décevoir un groupe, faire un tirage aléatoire pour les tableaux à faire)
+
+\item Remettre en commun une deuxième fois. Introduire l'idée que l'aléatoire met plus d'instructions à être décrit : Ce qui s'est normalement vu pendant la course. Réutiliser les résultats de la première tâche, notamment en impliquant les groupes n'ayant pas tout fait : Leur faire deviner quels sont les tableaux demandant le plus d'instructions à être décrit.
+
+\item Institutionnalisation + Trace écrite + Questions.
+\end{enumerate}
+
+\bigskip
+
+(Histoire de l'activité : Kolmo est un peintre s'illustrant dans le pixel art / mosaïque (les élèves de primaire en font normalement). Il est reconnu pour faire des tableaux "aléatoires", sans vrai forme. Étant invité partout, ce dernier n'a plus le temps de reproduire ses tableaux dans les expositions. Il décide alors de construire un robot pour l'aider: Ce robot lui permet d'encoder ses tableaux en une suite d'instructions simples, telles que "Mettre un pixel ici", "Tracer une ligne verticale / horizontale / diagonale entre ici et là".)
+
+
+\newpage
+
+\section{Enjeu choisi}
+\label{sec:enjeu}
+
+Comme dit précédemment, nous avons choisi d'aborder la notion d'aléatoire en informatique théorique. Étant donné qu'un ordinateur suit une liste d'instructions prédéterminées, il leur est impossible de générer une suite "vraiment" aléatoire. Il est donc important de pouvoir mesurer ce que l'on appelle intuitivement "aléatoire" afin d'éviter de retrouver des motifs pouvant être utilisés par des agents malicieux.
+
+\bigskip
+
+\underline{VERSION PROF} : Le mathématicien Andreï Kolmogorov propose dès 1963 une formalisation de ce que l'on peut considérer comme une mesure de l'aléa d'une chaîne de caractère. Pour ce dernier, une chaîne est d'autant plus aléatoire que cette dernière prend d'instructions à décrire. Formellement, la Complexité de Kolmogorov d'une chaîne correspond à la taille du plus petit programme produisant la chaîne recherchée (Notons que la complexité dépend a priori du langage choisi initialement). La notion est facilement joignable à la notion de compressibilité, de calculabilité (La complexité de Kolmogorov est incalculable), et même à des notions de complexité (Des inclusions de classes de complexité ont utilisé pour oracle cette notion). L'enjeu est avant tout de construire le parallèle entre aléa, difficulté de description et présence de motifs dans un objet. Une mauvaise génération d'aléa pourrait faciliter des attaques en cryptographie, peut entraîner des biais dans des simulations...
+
+\vspace{2em}
+
+\underline{VERSION ÉLÈVE} :\\
+
+\hrule
+
+\vspace{2em}
+
+\begin{center}
+\Large{\textbf{\underline{Les tableaux de Kolmo}}}
+\end{center}
+\Large{
+Un ordinateur ne peut pas tout faire. Parce que ces derniers suivent une liste d'instructions prédéterminée, il leur est par exemple impossible de créer des objets aléatoires. \textit{Les tableaux de Kolmo} illustrent comment les informaticiens parlent alors d'aléa : Un objet est dit aléatoire si ce dernier ne peut être décrit de manière concise. La taille minimale d'une description d'un objet est nommée \textbf{Complexité de Kolmogorov} de l'objet. Cette description de l'aléatoire est importante dans plusieurs domaines, tels que la \textbf{Cryptologie}, la \textbf{Simulation} ou encore le \textbf{Divertissement}.
+
+}
+
+\vspace{2em}
+\hrule
+\vspace{1em}
+
+\normalsize{(Les derniers termes en gras ont évidemment vocation à être développés à l'oral)}
+
+\vspace{2em}
+
+\section{Rapport de la séance}
+
+À l'issue de cette première séance, nous sommes agréablement surpris de constater que l'activité manuelle a été accueillie très positivement (nous étions inquiet que la recherche d'une solution optimale puisse paraître ennuyante). Les élèves étaient investis et ont globalement joué le jeu. À tel point que lors de la sélection de groupes pour la partie course, tous les élèves se sont portés volontaires (dur de choisir).\\
+
+Nous avions cependant mal compris le fonctionnement de la classe (l'activité demandait un peu moins d'une heure) : Nous nous sommes vus contraints d'accorder moins de temps pour la première partie (ce qui n'a pas empêché les élèves de l'apprécier). Ce manque de temps (et donc de pratique) s'est ressenti lors de l'institutionnalisation, lorsque nous avons demandé aux élèves quels étaient selon eux les tableaux les plus difficiles à décrire. Nous avons obtenu quelques réponses différentes, mais dans l'ensemble, la majorité des élèves ont pu intuiter le lien entre aléa et longueur de description.
+
+\newpage
+
+Néanmoins, nous sommes contraints de constater que l'institutionnalisation n'a pas appelé aux connaissances personnelles des élèves assez rapidement : Peu d'élèves étaient investis pour donner une utilisation de l'aléatoire dans le divertissement (peut-être est-ce également une question trop compliquée pour eux?). Certains élèves ont compris l'idée derrière cette notion, mais beaucoup ont décrochés sur la fin (explication de la cryptologie et de la simulation). Il semble donc nécessaire de réécrire la trace écrite afin d'impliquer plus rapidement les élèves, sans chercher à tracer le lien entre le sens profond de l'activité et des applications réelles auxquelles les élèves ne sont pas forcément sensibles.\\
+
+
+Nous somme également surpris de constater qu'il est compliqué pour les élèves de "voir les lignes" : A plusieurs reprises, les élèves se sont échinés à donner la solution triviale (pixel par pixel) sans voir le bénéfice de tracer une ligne. Comme l'institutrice nous l'a fait remarquer, si l'élève ne voit pas le bénéfice de tracer une ligne plutôt que de donner la solution pixel par pixel, alors ce dernier sera plus enclin à donner la solution pixel par pixel. (Certains élèves étaient suffisamment rapide pour donner chaque coordonnées très rapidement).
+
+
+\vspace{2em}
+
+
+\section{Notes pour le futur}
+
+Si cette activité intéresse de futurs groupes, nous donnons ici quelques notes sur ce qu'il semble pertinent d'améliorer :
+\begin{itemize}
+\item Le matériel : Nous avons choisi de donner une grille 6x6, et 22 pixels en papier de chaque couleur pour chaque groupe de trois. Bien que les élèves semblent aimer cette manipulation, le matériel est assez compliqué à manipuler de manière efficace. Il faut donc penser à prévoir un matériel assez grand pour pouvoir le manipuler facilement, et pouvoir le préparer rapidement (en tant qu'animateur, il faut donner à chaque groupe une vingtaine de pixels de chaque couleur, ce qui est compliqué pour de petits pixels).\\
+Néanmoins, il est également possible de chercher une autre solution de présentation afin de réduire la consommation de papier pour cette activité. Il est également intéressant de penser à inclure des repères de coordonnées semblables aux coordonnées d'un plateau d'échecs afin que les élèves se repèrent facilement.
+
+\item Organisation de la première partie : Nous avons donné 6 tableaux à reproduire à chaque groupe. En une quinzaine de minutes, les groupes les plus rapides ont pu faire 4 tableaux (même s'ils semblaient avoir compris l'idée, et ne semblaient pas vouloir faire les autres car trop simple), alors que les groupes les plus lents ont réalisé un seul tableau. Dans l'ensemble, le calibrage était assez bon, il suffirait de réduire le nombre de tableaux à quatre afin d'avoir un calibrage parfait (bien que ceci n'offre pas une répartition idéale entre peintre, robot et vérificateur). Cependant, réduire le nombre de tableaux ne permettrait pas d'offrir des tableaux vraiment aléatoires, faussement aléatoires, difficiles à décrire simplement mais faisable, vraiment simples, où la description minimale réduit beaucoup le nombre d'instructions, où rajouter une instruction facilite grandement la tâche $\ldots$. Étant donné que la question du jeu d'instruction original n'a pas pu être abordé, il peut être pertinent d'enlever ce dernier type de tableau.
+
+\item Course : Afin de ne pas décevoir un des groupes au tableau, nous avons décidé de présenter les modalités de la course avant coup, et de laisser les groupes s'arranger entre eux pour savoir lequel aura le tableau du dessus et du dessous (sans savoir lequel est aléatoire et l'autre plus facile). Les deux groupes ont offert une solution pixel par pixel! Nous attendions une solution simple de la part du groupe ayant le tableau plus ordonné: Ce tableau était uniquement constitué de lignes. Mais comme dit plus haut, si l'élève ne voit pas immédiatement le bénéfice d'une ligne, ce dernier ne l'utilisera pas (les robots devinaient que leur camarade voulait représenter une ligne et prédisaient les prochaines instructions).
+
+\item Trace écrite (+ institutionnalisation). Il est important de trouver un moyen d'impliquer l'élève immédiatement dans cette expérience, sans chercher à tracer le lien entre le sens profond de l'activité et des notions réelles auxquelles l'élève n'est pas forcément sensible. Par divertissement, nous espérions entendre l'application "Jeux-vidéos" (qui est apparue très tard). Insister immédiatement et plus fortement sur cette application pourrait permettre de maintenir le contact plus longtemps. Il semble bon de limiter les applications plus concrètes (Cryptologie et simulation) à un lien vague, après avoir raccroché aux Jeux vidéos.
+\end{itemize}
+
+
+\end{document}
\ No newline at end of file
diff --git a/Pixels/FicheDePreparation/2025_HasleyKazem_FicheDePreparation.pdf b/Pixels/FicheDePreparation/2025_HasleyKazem_FicheDePreparation.pdf
new file mode 100644
index 0000000..26814a9
Binary files /dev/null and b/Pixels/FicheDePreparation/2025_HasleyKazem_FicheDePreparation.pdf differ
diff --git a/Pixels/FicheDePreparation/2025_HasleyKazem_FicheDePreparation.tex b/Pixels/FicheDePreparation/2025_HasleyKazem_FicheDePreparation.tex
new file mode 100644
index 0000000..ce3e137
--- /dev/null
+++ b/Pixels/FicheDePreparation/2025_HasleyKazem_FicheDePreparation.tex
@@ -0,0 +1,118 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage[french]{babel}
+\usepackage[T1]{fontenc}
+\usepackage{mathrsfs}
+
+\usepackage[a4paper,width=280mm,top=10mm,bottom=20mm, landscape]{geometry}
+
+\usepackage{makecell}
+\usepackage{booktabs}
+\usepackage{array}
+\usepackage{subfig}
+\usepackage{amsmath,amsfonts,amssymb}
+\usepackage{tikz}
+\usepackage{tikz-cd}
+\usetikzlibrary{shapes}
+\usepackage{mathtools}
+\usepackage{titlesec}
+\usepackage{enumitem}
+\usepackage{listings}
+\usepackage{mathdots}
+\usepackage{cancel}
+\usepackage{comment}
+
+\usepackage{makeidx}
+
+\usepackage{tgpagella}
+\makeindex
+
+\usepackage[utf8]{inputenc}
+
+\usepackage{subfiles}
+
+\renewcommand{\arraystretch}{1.5}
+
+
+\renewcommand\theadalign{c}
+\renewcommand\theadfont{\textfont}
+\renewcommand\theadgape{\Gape[4pt]}
+\renewcommand\cellgape{\Gape[4pt]}
+
+\title{Fiches de préparation}
+
+\author{William Hasley \& Nowar Kazem}
+\date{}
+
+\begin{document}
+\begin{titlepage}
+
+\begin{center}
+\begin{tabular}{|c|>{\hsize=0.3\hsize\centering\arraybackslash}c|c|c|c|}
+\hline
+\multicolumn{5}{|c|}{
+William Hasley \& Nowar Kazem} \\
+\hline
+\multicolumn{1}{|l|}{\textbf{Classe} : CM1/CM2} & \multicolumn{3}{|l|}{\textbf{Titre} : Pixels.} & \multicolumn{1}{|l|}{\textbf{Séance n°1}} \\
+\hline
+\multicolumn{5}{|l|}{\textbf{Compétences travaillées} : Communication, Séquence d'instruction, Aléatoire théorique en Informatique.} \\
+\multicolumn{5}{|l|}{\textbf{Objectifs} : Introduire la notion de Complexité de Kolmogorov, il est impossible d'avoir du vrai aléatoire sur un ordinateur.} \\
+\hline
+\textbf{Activité} & \textbf{Script} & \textbf{Notes/Objectifs} & \textbf{Matériel} & \textbf{Temps (min)} \\
+\hline
+\thead{Présentation\\de l'activité} & \thead{
+ - se présenter \\
+ - Raconter l'histoire de Kolmo. \\
+ - Faire un exemple de tableau, reformulation\\
+ - Remarquer qu'il existe toujours\\ la solution naïve.\\
+ - Les dispatcher en groupes\\ de 4 ou 3 (Maintenant car\\ reviennent du "temps calme")
+ } & \thead{Contextualiser \\ Transmettre le but : \\Le moins d'instruction possible!} & \thead{Tableau pour exemple\\(Grille vide)} & \thead{8} \\
+\hline
+\thead{Distribution\\du matériel} & \thead{
+ - Distribuer une grille par groupe\\
+ - Distribuer les tableaux\\
+ - Distribuer les groupes de Pixels\\ (Les garder entre même couleur!!)
+} & \thead{faire que ça soit rapide} & \thead{- Grille 6x6\\-Les pixels\\ -Les tableaux} & \thead{3} \\
+\hline
+\thead{Activité} & \thead{
+ - passer dans les rangs pour voir\\ si tout se passe bien\\
+ - ajouter une règle de construction\\ pour les plus rapide\\
+ - demander de prouver l'optimalité\\ pour les encore plus rapide
+} & \thead{faire attention au volume sonore} & \thead{*} & \thead{20} \\
+\hline
+\thead{Remise en commun} & \thead{
+ - reprendre l'attention, Bien passé?\\
+ - Prendre deux groupes de deux\\ pour faire une course!\\
+ - Deux tableaux différents, \\ un aléatoire et l'autre un pattern,\\ le groupe le plus rapide gagne.\\
+ - Pointer le fait que le tableau aléatoire met plus de temps.
+} & \thead{Montrer que l'aléatoire prend\\ plus d'instruction à décrire} &\thead{Deux \textbf{GRANDS} exemples} & \thead{5} \\
+\hline
+\thead{Nouvelle activité} & \thead{
+ - Afficher trois tableaux pseudo-aléatoires \\ sur la TV / le tableau.\\
+ - Réflexion en groupe pendant un temps\\
+ - Vote comme remise en commun.
+ } & \thead{Identifier le tableau le plus aléatoire\\(Le plus long à décrire)} & \thead{- Trois \textbf{Grands} tableaux en PDF} & \thead{7} \\
+\hline
+\thead{Institutionnalisation} & \thead{
+ - Pourquoi est-ce de l'informatique?\\
+ - faire reformuler / interpréter personnellement.\\
+ - distribuer la trace écrite (+ la lire).
+} & \thead{être clair} & \thead{- trace écrite} & \thead{10} \\
+\hline
+\multicolumn{4}{|l|}{} &
+\multicolumn{1}{|c|}{\textbf{Total :} 53} \\
+\hline
+\end{tabular}
+\end{center}
+\end{titlepage}
+
+\newpage
+
+\textbf{Institutionnalisation (Version L3)}\\
+ Parfois, l'informaticien se demande ce qu'il peut faire, mais aussi ce qu'il ne peut pas faire : Un exemple de ce qu'un ordinateur ne peut pas faire est du vrai aléatoire. Nous devons donc nous réduire à de la génération pseudo-aléatoire. Mais comment quantifier "l'aléa" d'un générateur? Le mathématicien Kolmogorov (avec Solmonof) a tenté de donner un sens par notre analogie : Plus une chaîne semble aléatoire, plus cette dernière est difficile à décrire. Ici, Kolmo (oui très subtile...) est reconnaissable car ses tableaux sont vraiment aléatoires. Cette notion rejoint la compression de données.\\
+Il est également possible de partir sur l'incalculabilité de la complexité de Kolmogorov $\to$ Des trucs sont vraiment incalculables. Il sera impossible de créer un robot qui donne la plus petite description des tableaux! (enfin si, parce que ce modèle est très réduit, il manque les boucles et autre...).\\
+L'aléatoire est utilisé en Cryptologie, en Simulation ou encore dans les divertissement. Pour aller plus loin, la notion de complexité de Kolmogorov a été utilisé pour démontrer des inclusions de classes de complexité (c.f Wiki).
+
+\end{document}
+
+
diff --git a/Pixels/Materiel/collage.pdf b/Pixels/Materiel/collage.pdf
new file mode 100644
index 0000000..ca4850d
Binary files /dev/null and b/Pixels/Materiel/collage.pdf differ
diff --git a/Pixels/Materiel/course.pdf b/Pixels/Materiel/course.pdf
new file mode 100644
index 0000000..36beff9
Binary files /dev/null and b/Pixels/Materiel/course.pdf differ
diff --git a/Pixels/Materiel/grid_generator.py b/Pixels/Materiel/grid_generator.py
new file mode 100644
index 0000000..681fee7
--- /dev/null
+++ b/Pixels/Materiel/grid_generator.py
@@ -0,0 +1,148 @@
+import numpy as np
+from enum import Enum
+from PIL import Image, ImageDraw
+
+
+Red = [255, 0, 0]
+Green = [0, 255, 0]
+Blue = [0, 0, 255]
+Black = [0, 0, 0]
+White = [255, 255, 255]
+
+Colors = [Red, Green, Blue, Black, White]
+
+class IterType(Enum):
+ CoordIter = 0
+ CellIter = 1
+
+class Grid:
+
+ cell_nb = 6
+ cell_size = 200
+
+ color_matrix = []
+
+ iterator_index = (0, 0)
+ iterator_type = IterType.CoordIter
+
+ def __init__(self, cell_nb = 6, cell_size = 200):
+ self.cell_nb = cell_nb
+ self.cell_size = cell_size
+ self.color_matrix = 255 * np.ones((cell_nb, cell_nb, 3), int)
+
+ def __str__(self):
+ return self.color_matrix.__str__()
+
+ def __iter__(self):
+ self.iterator_index = (-1, self.cell_nb)
+ return self
+
+ def __next__(self):
+
+ '''
+ La valeur de retour dépend du choix du type d'itérator!
+ Un CellIter renverra chaque case (liste RGB) alors qu'un
+ CoordIter renverra les couples (ligne, colonne) dans l'ordre lexicographique
+ '''
+
+ lin, col = self.iterator_index
+ if(col + 1 >= self.cell_nb):
+ if(lin + 1 >= self.cell_nb):
+ raise StopIteration
+ else:
+ self.iterator_index = (lin + 1, 0)
+ if(self.iterator_type == IterType.CoordIter):
+ return self.iterator_index
+ elif(self.iterator_type == IterType.CellIter):
+ return self.color_matrix[lin + 1, 0]
+ else:
+ self.iterator_index = (lin, col + 1)
+ if(self.iterator_type == IterType.CoordIter):
+ return self.iterator_index
+ elif(self.iterator_type == IterType.CellIter):
+ return self.color_matrix[lin, col + 1]
+
+
+ def set_iter_type(self, iter_type):
+ self.iterator_type = iter_type
+
+ def make_image(self):
+ outline_size = int(self.cell_size / 100)
+ grid_sep_size = int(outline_size / 2)
+ total_size = 2 * (outline_size - grid_sep_size) + self.cell_nb * (self.cell_size + grid_sep_size)
+ new_image = Image.new('RGB', (total_size, total_size))
+
+ draw_obj = ImageDraw.Draw(new_image)
+ draw_obj.rectangle([(0, 0), (total_size, outline_size)], fill = "#000000", outline = None)
+ draw_obj.rectangle([(0, 0), (outline_size, total_size)], fill = "#000000", outline = None)
+ draw_obj.rectangle([(total_size - outline_size, outline_size), (total_size, total_size)], fill = "#000000", outline = None)
+ draw_obj.rectangle([(outline_size, total_size - outline_size), (total_size, total_size)], fill = "#000000", outline = None)
+
+ self.set_iter_type(IterType.CoordIter)
+
+ for lin, col in iter(self):
+ first_coord = ((outline_size + col * (self.cell_size + grid_sep_size)), (outline_size + lin * (self.cell_size + grid_sep_size)))
+ second_coord = (first_coord[0] + self.cell_size, first_coord[1] + self.cell_size)
+ coord_list = [first_coord, second_coord]
+ draw_obj.rectangle(coord_list, fill = tuple(self.color_matrix[lin, col]), outline="#000000")
+
+
+ return new_image
+
+ def plot_pixel(self, x, y, color):
+ try:
+ self.color_matrix[y, x] = color
+ except IndexError:
+ print("plot_pixel -> Invalid Coordinates (" + str(x) + ", " + str(y) + ")")
+
+ return self
+
+ def fill_grid(self, color):
+ self.iterator_type = IterType.CoordIter
+ for lin, col in iter(self):
+ self.color_matrix[lin, col] = color
+
+ return self
+
+ def plot_horizontal_line(self, begin_coord, end_coord, color):
+ for index in range (begin_coord[0], end_coord[0] + 1):
+ self.plot_pixel(index, begin_coord[1], color)
+
+ return self
+
+ def plot_vertical_line(self, begin_coord, end_coord, color):
+ for index in range (begin_coord[1], end_coord[1] + 1):
+ self.plot_pixel(begin_coord[0], index, color)
+
+ return self
+
+ def plot_diagonal_line(self, begin_coord, end_coord, color):
+
+ if (np.abs(end_coord[0] - begin_coord[0]) != np.abs(end_coord[1] - begin_coord[1])):
+ print("plot_diagonal_line -> Must be a 45° Diagonal!")
+ return self
+
+ else:
+ cur_x = begin_coord[0]
+ cur_y = begin_coord[1]
+ for _ in range(np.abs(end_coord[0] - begin_coord[0]) + 1):
+ self.plot_pixel(cur_x, cur_y, color)
+ if(end_coord[0] >= begin_coord[0]):
+ cur_x += 1
+ else:
+ cur_x -= 1
+
+ if(end_coord[1] >= begin_coord[1]):
+ cur_y += 1
+ else:
+ cur_y -= 1
+
+ return self
+
+ def flip_horizontal(self):
+ self.color_matrix = np.flip(self.color_matrix, 1)
+ return self
+
+ def flip_vertical(self):
+ self.color_matrix = np.flip(self.color_matrix, 0)
+ return self
diff --git a/Pixels/Materiel/howto.md b/Pixels/Materiel/howto.md
new file mode 100644
index 0000000..5586e1f
--- /dev/null
+++ b/Pixels/Materiel/howto.md
@@ -0,0 +1,40 @@
+# **Génération de Tableaux**
+
+
+Ce court document présente documente l'utilisation du générateur de tableaux fourni dans le cadre de l'activité "Pixels".
+
+Le générateur se décompose en deux fichiers :
+ - **grid_generator.py** : Définitions des structures de grille et des opérations sur les grilles
+ - **testbed.py** : Fichier de test où il est préférable de regrouper les tableaux (Fichier d'exemple)
+
+
+
+
+
+# Utilisation du générateur de grille
+
+Le fichier *grid_generator.py* déclare la construction de la classe "Grid", représentant un tableau. Cette classe contient une matrice carré, dont les entrées sont des listes à trois éléments **[R, G, B]** (entre $0$ et $255$).
+
+Sont également définies quelques couleurs de base : Red, Green, Blue, Black, White.
+
+Lors de la création d'un objet Grid, il est possible de modifier le nombre de cases que comporte une grille (paramètre *cell_nb*, par défaut vaut $6$), ainsi que la taille d'une cellule en pixels réels (paramètre *cell_size*, par défaut $200$ pixels).
+
+*Note : Le système de coordonées est pour le moment fondé sur des couples $(x, y)$ représentant les coordonées réelles des pixels (commençant donc à $(0,0)$). Il peut être pertinent d'implémenter la conversion d'un système de coordonées semblables aux échecs, plus maniable pour des élèves de CM2*
+
+Quelques fonctions sont disponibles pour intéragir avec le tableau:
+
+- **make_image(name)** : Génère un fichier de nom "name" représentant le tableau
+
+- **plot_pixel(x, y, color)** : Colorie le pixel $(x, y)$ avec la couleur color.
+
+- **fill_grid(color)** : Remplit la grille avec la couleur color.
+
+- **plot_horizontal_line((x_1, y_1), (x_2, y_2), color)** : Trace une ligne horizontale commençant en $(x_1, y_1)$ et terminant en $(x_2, y_2)$ avec la couleur color. Il est supposé que $y_1 = y_2$ pour tracer une ligne horizontale. Si ces deux valeurs diffèrent, $y_1$ est utilisé par défaut.
+
+- **plot_vertical_line((x_1, y_1), (x_2, y_2), color)** : Trace une ligne verticale commençant en $(x_1, y_1)$ et terminant en $(x_2, y_2)$ avec la couleur color. Il est supposé que $x_1 = x_2$ pour tracer une ligne verticale. Si ces deux valeurs diffèrent, $x_1$ est utilisé par défaut.
+
+- **plot_diagonal_line((x_1, y_1), (x_2, y_2), color)** : Trace une ligne diagonale commençant en $(x_1, y_1)$ et terminant en $(x_2, y_2)$ avec la couleur color. Il est supposé que $|x_1 - x_2| = |y_1 - y_2|$ pour tracer une ligne diagonale. Si ces deux valeurs diffèrent, la diagonale ne sera pas tracée.
+
+- **flip_horizontal()** : Permet de retourner le tableau horizontalement
+
+- **flip_vertical()** : Permet de retourner le tableau verticalement
\ No newline at end of file
diff --git a/Pixels/Materiel/readme.md b/Pixels/Materiel/readme.md
new file mode 100644
index 0000000..97a445b
--- /dev/null
+++ b/Pixels/Materiel/readme.md
@@ -0,0 +1,40 @@
+# **Génération de Tableaux**
+
+
+Ce court document présente documente l'utilisation du générateur de tableaux fourni dans le cadre de l'activité "Pixels".
+
+Le générateur se décompose en deux fichiers :
+ - **grid_generator.py** : Définitions des structures de grille et des opérations sur les grilles
+ - **testbed.py** : Fichier de test où il est préférable de regrouper les tableaux (Fichier d'exemple)
+
+
+
+
+
+# Utilisation du générateur de grille
+
+Le fichier *grid_generator.py* déclare la construction de la classe "Grid", représentant un tableau. Cette classe contient une matrice carré, dont les entrées sont des listes à trois éléments **[R, G, B]** (entre $0$ et $255$).
+
+Sont également définies quelques couleurs de base : Red, Green, Blue, Black, White.
+
+Lors de la création d'un objet Grid, il est possible de modifier le nombre de cases que comporte une grille (paramètre *cell_nb*, par défaut vaut $6$), ainsi que la taille d'une cellule en pixels réels (paramètre *cell_size*, par défaut $200$ pixels).
+
+*Note : Le système de coordonées est pour le moment fondé sur des couples $(x, y)$ représentant les coordonées réelles des pixels (commençant donc à $(0,0)$). Il peut être pertinent d'implémenter la conversion d'un système de coordonées semblables aux échecs, plus maniable pour des élèves de CM2*
+
+Quelques fonctions sont disponibles pour intéragir avec le tableau:
+
+- **make_image(name)** : Génère un fichier de nom "name" représentant le tableau
+
+- **plot_pixel(x, y, color)** : Colorie le pixel $(x, y)$ avec la couleur color.
+
+- **fill_grid(color)** : Remplit la grille avec la couleur color.
+
+- **plot_horizontal_line((x_1, y_1), (x_2, y_2), color)** : Trace une ligne horizontale commençant en $(x_1, y_1)$ et terminant en $(x_2, y_2)$ avec la couleur color. Il est supposé que $y_1 = y_2$ pour tracer une ligne horizontale. Si ces deux valeurs diffèrent, $y_1$ est utilisé par défaut.
+
+- **plot_vertical_line((x_1, y_1), (x_2, y_2), color)** : Trace une ligne verticale commençant en $(x_1, y_1)$ et terminant en $(x_2, y_2)$ avec la couleur color. Il est supposé que $x_1 = x_2$ pour tracer une ligne verticale. Si ces deux valeurs diffèrent, $x_1$ est utilisé par défaut.
+
+- **plot_diagonal_line((x_1, y_1), (x_2, y_2), color)** : Trace une ligne diagonale commençant en $(x_1, y_1)$ et terminant en $(x_2, y_2)$ avec la couleur color. Il est supposé que $|x_1 - x_2| = |y_1 - y_2|$ pour tracer une ligne diagonale. Si ces deux valeurs diffèrent, la diagonale ne sera pas tracée.
+
+- **flip_horizontal()** : Permet de retourner le tableau horizontalement
+
+- **flip_vertical()** : Permet de retourner le tableau verticalement
diff --git a/Pixels/Materiel/testbed.py b/Pixels/Materiel/testbed.py
new file mode 100644
index 0000000..83f485b
--- /dev/null
+++ b/Pixels/Materiel/testbed.py
@@ -0,0 +1,172 @@
+from grid_generator import *
+import random
+
+
+
+
+if __name__ == "__main__":
+
+ # Grillage Simple
+
+ g = Grid(cell_nb = 6)
+
+ g.plot_vertical_line((1, 0), (1, 5), Red)
+ g.plot_vertical_line((4, 0), (4, 5), Red)
+
+ g.plot_horizontal_line((0, 1), (5, 1), Red)
+ g.plot_horizontal_line((0, 4), (5, 4), Red)
+
+ g.plot_diagonal_line((0, 0), (5, 5), White)
+ g.plot_diagonal_line((5, 0), (0, 5), White)
+ g.make_image().save("grid_facile.png")
+
+
+ # Montagne
+
+ g = Grid(cell_nb = 6)
+
+ g.plot_diagonal_line((3, 2), (5, 4), Blue)
+ g.plot_diagonal_line((3, 1), (5, 3), Blue)
+ g.plot_diagonal_line((2, 2), (5, 5), Blue)
+
+ g.plot_diagonal_line((0, 5), (3, 2), Green)
+ g.plot_diagonal_line((0, 4), (3, 1), Green)
+
+ g.make_image().save("montagne.png")
+
+
+ # Aléatoire Total
+
+ g = Grid(cell_nb = 6)
+
+ color_cnt = 0
+
+ for rnd_pixel in range(35):
+ x = random.randint(0, 5)
+ y = random.randint(0, 5)
+ #while(g.color_matrix[y, x, :].tolist() == White):
+ # x = random.randint(0, 5)
+ # y = random.randint(0, 5)
+ g.plot_pixel(x, y, Colors[color_cnt])
+ color_cnt = color_cnt + 1 if (color_cnt < 3) else 0
+
+ g.make_image().save("random.png")
+
+
+ # Forme Penchée
+
+ g = Grid(cell_nb = 6)
+
+ g.plot_horizontal_line((0, 4), (2, 4), Red)
+ g.plot_pixel(0, 3, Red)
+
+ g.plot_vertical_line((1, 0), (1, 2), Blue)
+ g.plot_pixel(2, 0, Blue)
+
+ g.plot_horizontal_line((3, 1), (5, 1), Green)
+ g.plot_pixel(5, 2, Green)
+
+ g.plot_vertical_line((4, 3), (4, 5), Black)
+ g.plot_pixel(3, 5, Black)
+
+ g.flip_horizontal()
+
+ g.make_image().save("forme.png")
+
+
+ # Damier
+
+ g = Grid(cell_nb = 6)
+
+ g.plot_diagonal_line((0, 0), (5, 5), Black)
+ g.plot_diagonal_line((2, 0), (5, 3), Black)
+ g.plot_diagonal_line((0, 2), (3, 5), Black)
+ g.plot_diagonal_line((4, 0), (5, 1), Black)
+ g.plot_diagonal_line((0, 4), (1, 5), Black)
+
+ #g.plot_diagonal_line((0, 5), (5, 0), Red)
+ #g.plot_diagonal_line((0, 3), (3, 0), Green)
+ #g.plot_diagonal_line((2, 5), (5, 2), Green)
+
+
+ g.make_image().save("damier.png")
+
+
+ # presque_random
+
+ g = Grid(cell_nb = 6)
+
+ g.plot_diagonal_line((1,0), (3,2), Red)
+ g.plot_horizontal_line((3, 0), (5, 0), Red)
+
+ g.plot_pixel(0, 1, Black)
+ g.plot_pixel(1, 1, Black)
+ g.plot_pixel(0, 2, Black)
+ g.plot_pixel(0, 3, Green)
+ g.plot_pixel(3, 1, Blue)
+ g.plot_pixel(4, 1, Blue)
+
+ g.plot_diagonal_line((2, 2), (4, 4), Blue)
+ g.plot_diagonal_line((1, 2), (3, 4), Green)
+ g.plot_pixel(4, 2, Green)
+ g.plot_pixel(4, 3, Green)
+
+ g.plot_pixel(5, 3, Black)
+ g.plot_pixel(5, 4, Black)
+
+ g.plot_pixel(1, 4, Blue)
+ g.plot_pixel(1, 5, Blue)
+
+ g.plot_pixel(2, 4, Red)
+ g.plot_pixel(2, 5, Red)
+
+ g.plot_pixel(3, 5, Blue)
+ g.plot_pixel(4, 5, Black)
+
+ g.make_image().save("near_random.png")
+
+
+# ----- Course -----
+
+
+ g = Grid(cell_nb = 7, cell_size = 400)
+
+ #g.plot_horizontal_line((0, 0), (6, 0), Black)
+ g.plot_vertical_line((6, 0), (6, 6), Green)
+ #g.plot_horizontal_line((0, 6), (6, 6), Blue)
+ g.plot_vertical_line((0, 0), (0, 6), Green)
+
+ g.plot_horizontal_line((1, 1), (5, 1), Red)
+ g.plot_horizontal_line((1, 5), (5, 5), Red)
+
+ g.plot_vertical_line((5, 2), (5, 5), Blue)
+ g.plot_vertical_line((1, 1), (1, 4), Blue)
+
+
+ g.plot_vertical_line((2, 2), (2, 4), Green)
+ g.plot_vertical_line((4, 2), (4, 4), Green)
+
+ g.plot_horizontal_line((2, 2), (3, 2), Black)
+ g.plot_horizontal_line((3, 4), (4, 4), Black)
+
+
+
+ g.make_image().save("course_set.png")
+
+
+ g = Grid(cell_nb = 7, cell_size = 400)
+
+ color_cnt = 0
+
+ for rnd_pixel in range(48):
+ x = random.randint(0, 6)
+ y = random.randint(0, 6)
+ #while(g.color_matrix[y, x, :].tolist() == White):
+ # x = random.randint(0, 5)
+ # y = random.randint(0, 5)
+ g.plot_pixel(x, y, Colors[color_cnt])
+ color_cnt = color_cnt + 1 if (color_cnt < 3) else 0
+
+ g.make_image().save("course_random.png")
+
+
diff --git a/Pixels/TraceEcrite/2025_HasleyKazem_TraceEcrite.pdf b/Pixels/TraceEcrite/2025_HasleyKazem_TraceEcrite.pdf
new file mode 100644
index 0000000..27e5d58
Binary files /dev/null and b/Pixels/TraceEcrite/2025_HasleyKazem_TraceEcrite.pdf differ
diff --git a/Pixels/TraceEcrite/2025_HasleyKazem_TraceEcrite.tex b/Pixels/TraceEcrite/2025_HasleyKazem_TraceEcrite.tex
new file mode 100644
index 0000000..18af735
--- /dev/null
+++ b/Pixels/TraceEcrite/2025_HasleyKazem_TraceEcrite.tex
@@ -0,0 +1,74 @@
+\documentclass{article}
+
+\usepackage[tmargin=2cm,rmargin=1in,lmargin=1in,margin=0.85in,bmargin=2cm,footskip=.2in]{geometry}
+
+\usepackage[upright]{fourier} % PACKAGE QUI MODIFIE LA FONT DE BASE
+\usepackage[none]{hyphenat}
+\usepackage[utf8]{inputenc}
+\usepackage{tikz}
+\usepackage{tkz-tab}
+\usepackage{amsfonts}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage[mathscr]{eucal}
+\usepackage{bigints}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{pdfpages}
+\usepackage{centernot}
+\usepackage{witharrows}
+\usepackage[inline]{enumitem}
+%\usepackage{algorithm, algorithmic}
+\usepackage{cancel}
+
+\usepackage{stmaryrd}
+
+\usepackage{fancyhdr}
+\usepackage{graphicx}
+
+\pagestyle{fancy}
+\fancyhf{}
+\fancyhead{}
+\fancyfoot[C]{\thepage}
+
+\renewcommand{\headrulewidth}{0.4pt}
+\renewcommand{\footrulewidth}{0.4pt}
+
+\parindent 0ex
+
+
+
+
+\title{\textbf{Trace écrite Pixels}}
+\date{\textit{\today}}
+\author{Hasley William - 228}
+
+% Des commandes qui se font à chaque page --------
+\parindent 0ex
+
+
+\newcommand{\texte}{\begin{center}
+\Large{\textbf{\underline{Les tableaux de Kolmo}}}
+\end{center}\Large{
+Un ordinateur ne peut pas tout faire. Parce que ces derniers suivent une liste d'instructions prédéterminée, il leur est par exemple impossible de créer des objets aléatoires. \textit{Les tableaux de Kolmo} illustrent comment les informaticiens parlent alors d'aléa : Un objet est dit aléatoire si ce dernier ne peut être décrit de manière concise. La taille minimale d'une description d'un objet est nommée \textbf{Complexité de Kolmogorov} de l'objet. Cette description de l'aléatoire est importante dans plusieurs domaines, tels que la \textbf{Cryptologie}, la \textbf{Simulation} ou encore le \textbf{Divertissement}.
+
+}}
+
+\begin{document}
+
+\texte
+
+\vspace{2em}
+\hrule
+\vspace{2em}
+
+\texte
+
+\vspace{2em}
+\hrule
+\vspace{2em}
+
+\texte
+
+
+\end{document}
\ No newline at end of file