initial commit

docs/CahierDesCharches.md

@@ -0,0 +1,137 @@
+# Track Trends
+
+Cahier des charges Travail de diplôme Maxime Rohmer 2023
+
+## Contexte
+
+----
+
+Je suis le "Live Ticker" chargé de la Formule 1 pour le 20 minutes. On peut traduire cela comme commentateur de F1, avec tout de même l'importante subtilité que je ne commente pas avec la voix, mais avec le clavier. Mes commentaires sont sous la forme de commentaires écrits live qui s'ajoutent au fur et à mesure de l'évènement.
+Par exemple : "Tour 28/54, Hamilton a fini par s'arrêter et chausser des gommes tendres 13 tours après Verstappen. L'Anglais va voir plus de 15 secondes à rattraper, mais les gommes neuves et plus tendres que son rival devraient lui permettre s'il ne se fait pas trop ralentir par le trafic". En général avec un peu plus d'infos quand même et cela tous les 3-4 tours  
+
+Voici quelques exemples de précédents commentaires (Conseil : il y a un bouton pour montrer le feed dans l'ordre chronologique) :
+
+- ["Commentaire Grand Prix de Belgique 2022"](https://www.20min.ch/fr/story/les-leaders-du-championnat-en-fond-de-grille-937035758708)
+- ["Commentaire du Grand Prix de Singapour 2022"](https://www.20min.ch/fr/story/singapour-sous-la-pluie-depart-repousse-432150037887)
+
+!["Exemple commentaires"](../Images/ExampleLiveTicker.png)
+
+Pendant un Grand Prix, je dois constamment :
+
+- Écrire ce qu'il se passe dans le grand prix et expliquer les enjeux
+- Chercher régulièrement des médias à inclure pour diversifier mon live (Tweets, Images etc.)
+- Changer le titre et la description du live en fonction de l'évolution du Grand prix
+- Et accessoirement regarder le grand prix pour y comprendre quelque chose
+
+Avec tout ça, il est très difficile de garder un œil sur la page DATA de la F1TV qui fournit pourtant des informations précieuses.
+
+Je me retrouve parfois par exemple à ne pas parler de dépassements dans le peloton, car ils ne sont pas retransmis à la télé alors que c'est une information importante. Autre exemple, occasionnellement le classement ne reflète pas les vraies positions des pilotes. Les arrêts aux stands font que du coup des pilotes qui devraient être 15èmes se retrouvent 8ᵉ puisqu'ils ne sont pas encore arrêtés. Cela peut de temps en temps prêter à confusion.
+
+## Projet
+
+----
+
+Un outil de style compagnon sous forme d'application C# Windows Form qui récupère en temps réel les informations de la course et affiche les informations les plus importantes. Le but est non seulement de faciliter mon job, mais aussi faire en sorte d'améliorer la plus-value de mon travail en me permettant de fournir des commentaires qui ne sont pas disponibles pour le tout venant qui regarde simplement le flux RTS.
+
+Exemples:
+
+- Les pilotes qui sont proches (moins de 1-2 secondes qui sont donc en train de se battre).
+- Les pilotes qui améliorent leur temps au tour et ceux qui perdent le plus de temps
+- Le classement pondéré tenant compte des futurs arrêts au stand
+
+Maintenant afficher différemment les infos, c'est sympa, mais cela serait encore mieux de traiter ces data et de permettre des petites prédictions.
+
+Exemples :  
+
+- Prédire les arrêts aux stands en prenant en compte les baisses de performances des pneus
+- Prédire le pneu que le pilote va chausser s'il rentre aux stands dans le prochain tour
+- Prédire dans combien de tour tel pilote va rattraper tel autre pilote
+- Prédire combien de temps le pilote va perdre dans les stands en fonctions des arrêts précédents
+
+## Réalisation
+
+Malheureusement, la Formula 1 Management ne propose aucune API publique qui puisse nous permettre de faire ce projet "simplement".
+La raison la plus probable étant qu'Amazon avec son service AWS propose exactement ce genre de services pour le flux télévisé et il doit y avoir un contrat d'exclusivité.
+
+Il existe des API "Pirates" faites par la communauté, le problème est qu'elles ne sont pas forcément des plus pratiques à utiliser.
+
+Mais comme je possède un abonnement premium ++ à la F1TV, j'ai accès pour chaque grand prix à un flux vidéo nommé : DATA F1 CHANNEL
+
+Qui ressemble à ça :
+
+!["Data channel exemple"](../Images/Formula1DataChannel.png)
+
+Donc la seule façon que je vois de récupérer ces données est de les prendre directement sur ce feed.
+
+Même si le but final de l'application est de faire pleins de choses super avec les datas, le gros du projet va surtout être la récupération des données et leur stockage.
+
+Les données viennent du flux vidéo et ainsi dans un premier temps, il va falloir récupérer d'une manière ou d'une autre des images qui viennent d'un grand prix en direct ou en rediffusion.
+
+Ensuite, dans un second temps, il faut lire les informations directement sur l'image en utilisant une librairie prévue pour (exemple Tesseract) et vérifier l'intégrité de ces dernières pour qu'on puisse ensuite les stocker.
+
+Dans un troisième temps, il faut stocker toutes ces données dans une forme qui permette d'aller facilement faire des requêtes de récupération et déjà préparer des méthodes qui permettent de récupérer des infos importantes (ex : la moyenne des cinq derniers tours, le temps moyen d'arrêt etc.) pour faciliter la dernière étape
+
+Quand tout cela est fait, on peut ensuite s'amuser un peu avec les Data.
+
+La dernière étape est donc l'affichage. L'idée est de créer une Windows Form qui contienne toutes ces informations dans un format beaucoup plus lisible et avec laquelle on pourrait interagir pour permettre de plus facilement commenter les Grands Prix. (exemple plus bas avec un croquis de ce à quoi l'application pourrait ressembler)
+
+Voici la liste des données qui pourraient être affichées (Non contractuel, simplement des idées).
+
+- Les pilotes qui sont proches (moins de 1-2 secondes qui sont donc en train de se battre).
+- Les pilotes qui améliorent leur temps au tour et ceux qui perdent le plus de temps
+- Le classement pondéré tenant compte des futurs arrêts au stand
+- La moyenne de temps que les pilotes perdent dans les stands
+- La performance moyenne des 5 types de pneus
+- La moyenne de temps de chaque pilote sur le pneu actuel
+- Le nombre de points que chaque pilote gagnerait selon sa position
+- Le classement de la course
+
+Voire même si c'est possible :
+
+- Prédire les arrêts aux stands en prenant en compte les baisses de performances des pneus
+- Prédire le pneu que le pilote va chausser s'il rentre aux stands dans le prochain tour
+- Prédire dans combien de tour tel pilote va rattraper tel autre pilote
+- Prédire combien de temps le pilote va perdre dans les stands en fonctions des arrêts précédents
+- Prédire les temps au tour de chaque pilote selon l'usure des pneus
+
+Voici un exemple d'interface possible pour une page :
+
+!["Proto"](../Images/Prototype.png)
+
+## Cas d'utilisation
+
+----
+
+*On va considérer que tous les user ont un abonnement F1 TV PRO
+
+Un user veut récupérer les data :
+
+- Il ouvre son navigateur et lance la page DATA de la F1 TV
+- Il calibre la capture des data via le programme   (pour la première utilisation).
+- Il confirme que les données initiales sont bonnes (pour la première utilisation).
+- Il regarde tranquille son Grand Prix
+
+Le programme récupère les data :
+
+- Il récupère des images depuis la F1TV
+- Il utilise Tesseract (ou autre) pour en récupérer les infos.
+- Il met ces infos dans un Objet Pilote, dans un Objet course avec un attribut tour pour hiérarchiser les data
+
+Pour ce qui est de l'affichage, l'idée est de faire une application C# comme on l'a appris à l'école, mais avec assez de style pour qu'elle puisse être agréable à utiliser.
+
+Quand le programme affiche les data :
+
+- Il prend les données venant directement de la F1TV.
+- Il affiche différemment les données pour permettre une meilleure lisibilité
+- Il interprète avec des règles plutôt simples certaines data pour faire des miniprédictions ou aider à la lecture
+- Il récupère des infos d'autres courses pour les comparer et proposer des prédictions plus intéressantes
+
+## Difficultés techniques
+
+----
+
+- Récupérer un flux vidéo plutôt propre malgré les contres mesures de la F1 TV pour en empêcher la lecture par un logiciel
+- Si on doit passer par une capture d'écran, trouver un moyen de stocker les données de manière à prévoir que parfois un tour pourrait avoir plus de données qu'un autre, que le user peut mettre pause, ou même qu’il revienne en arrière.
+- Développer des algorithmes pour récupérer les données comme les différents pneus utilisés ou l'activation du DRS ainsi que développer des moyens de nettoyer les résultats de l'OCR (Par exemple utiliser différents champs redondants pour comparer les résultats)
+- Stocker les données sur une base pour les traiter plus tard tout en prévoyant un moyen de voir les stats live
+- Développer des algorithmes de prédiction qui prennent en compte d'anciennes courses pour tenter de prédire des choses comme les arrêts aux stands par exemple.

docs/index.md

@@ -0,0 +1,3 @@
+# Documentation diplome technicien ES 2023
+
+[insert content]

docs/jdb.md

@@ -0,0 +1,258 @@
+## J-1
+
+Avant de commencer pour de bon je veux être certain d'utiliser la bonne methode d'OCR
+
+Je vais tester IronOcr
+
+Source : https://www.c-sharpcorner.com/article/ocr-using-tesseract-in-C-Sharp/
+Doc : https://ironsoftware.com/csharp/ocr/docs/
+Examples : https://ironsoftware.com/csharp/ocr/examples/simple-csharp-ocr-tesseract/
+
+Avant d'utiliser la librairie je me demande si je dois utiliser un peu de post processing pour aider à la reconnaissance.
+
+Je peux soit utiliser l'image cropée directement :
+
+!["Image non traitée"](./Images/Screens/BlackToWhite0.png)
+
+Soit avec un filtre pour passer en noir et blanc laxiste
+
+!["Image traitée laxiste"](./Images/Screens/BlackToWhite1.png)
+
+Soit avec un filtre pour passer en noir et blanc stricte
+
+!["Image traitée stricte"](./Images/Screens/BlackToWhite2.png)
+
+Il va falloir faire des tests avec tous les noms et les chiffres pour trouver le plus efficace.
+
+Bon malheureusment Iron OCR semblait être une bonne alternative mais c'est une librairie privée qui demande une license pour être utilisée. Il va falloir trouver autre chose.
+
+En utilisant la librairie "Tesseract" qui existe on peut faire de la reconnaissance de texte avec un code plutôt simple :
+
+```Csharp
+TesseractEngine engine = new TesseractEngine(tessDataFolder.FullName,"eng", EngineMode.Default);
+            
+var tessImage = Pix.LoadFromMemory(ImageToByte(sample));
+
+Page page = engine.Process(tessImage);
+string text = page.GetText();
+```
+
+Voici la methode ImageToByte :
+https://stackoverflow.com/questions/7350679/convert-a-bitmap-into-a-byte-array
+
+```Csharp
+public static byte[] ImageToByte(Image img)
+{
+    using (var stream = new MemoryStream())
+    {
+        img.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
+            return stream.ToArray();
+        }
+}
+```
+
+Voici le code pour traiter plusieurs textes sur une seule image :
+
+```Csharp
+Page page = engine.Process(tessImage);
+            // Get the iterator for the page layout
+            using (var iter = page.GetIterator())
+            {
+                // Loop over the elements of the page layout
+                iter.Begin();
+                do
+                {
+                    // Declare a Rect variable to hold the bounding box
+                    Rect boundingBox;
+
+                    // Get the bounding box for the current element
+                    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out boundingBox))
+                    {
+                        g.DrawRectangle(Pens.Red,new Rectangle(boundingBox.X1,boundingBox.Y1,boundingBox.Width,boundingBox.Height));
+                    }
+
+                    // Get the text for the current element
+                    var text = iter.GetText(PageIteratorLevel.Word);
+                    tbxResult.Text += text.ToUpper() + Environment.NewLine;
+                } while (iter.Next(PageIteratorLevel.Word));
+            }
+```
+
+Etonnament, avec plus de texte, des noms qui étaient autrefois mal reconnus sont parfaitement interprêtés.
+
+Par exemple voici un exemple de reconnaisance de texte sur tous les pilotes :
+
+!["Screenshot de reconnaisance d'image complete"](./Images/Screens/TextRecognition1.png)
+
+On voit que le nom Leclerc est mal reconnu. Mais voici ce que cela donne quand on prend une image qui ne contient que le nom Leclerc :
+
+!["Screenshot de reconnaissance d'image cropée"](./Images/Screens/TextRecognition0.png)
+
+On voit ici que le nom Leclerc est très bien reconnu.
+
+Dans le premier exemple on peut voir que Tsunoda est reconnu comme "Reticin" ce qui n'est pas exactement pareil (lol)
+
+Et quand on isole le nom Tsunoda dans une image seule :
+
+!["Screenshot de reconnaissance de Tsunoda"](./Images/Screens/TextRecognition2.png)
+
+Il le lit "RETLELYY" ce qui n'est toujours pas exactement ca...
+
+Une meilleure résolution pourrait peut-être résoudre le problème en partie.
+
+Jusqu'ici les images étaient en presque 720P ce qui donne ceci :
+
+!["Tsunoda en 720P"](./Images/Screens/720PTsunoda.png)
+
+Et j'ai lancé une récupèration d'images en 1080p pour récupèrer ceci :
+
+!["Tsunoda en 1080P"](./Images/Screens/1080PTsunoda.png)
+
+On peut voir une certaine différence tout de même.
+
+Et quand on lance la reconnaissance :
+
+!["Reconnaissance Tsunoda en 1080P"](./Images/Screens/TextRecognition3.png)
+
+"Tsunoda n'est plus écrit "RETLELYY" mais "TSUNDDA" ce qui n'est pas parfait mais qui est déja beaucoup mieux.
+
+J'ai essayé de mettre l'engine de Tesseract en mode "JPN" comme Tsunoda est un nom japonais mais sans succès j'ai le même résultat.
+
+Comme la résolution est meilleure je me suis dit que peut être le filtre de passage en noir et blanc pourrait aider.
+
+J'ai écrit cette petite methode pour convertir l'image en noir et blanc :
+
+```Csharp
+private static Bitmap ConvertToBlackAndWhite(Bitmap inputBmp)
+        {
+            const int BLACK_TO_WHITE_TRESHOLD = 200;
+            Bitmap result = new Bitmap(inputBmp.Width, inputBmp.Height);
+
+            for (int y = 0; y < inputBmp.Height; y++)
+            {
+                for (int x = 0; x < inputBmp.Width; x++)
+                {
+                    Color pixelColor = inputBmp.GetPixel(x,y);
+                    if (pixelColor.R <= BLACK_TO_WHITE_TRESHOLD && pixelColor.G <= BLACK_TO_WHITE_TRESHOLD && pixelColor.B <= BLACK_TO_WHITE_TRESHOLD)
+                    {
+                        pixelColor = Color.FromArgb(0,0,0);
+                    }
+                    else
+                    {
+                        pixelColor = Color.FromArgb(255,255,255);
+                    }
+                    result.SetPixel(x,y,pixelColor);
+                }
+            }
+            return result;
+        }
+```
+
+Rien de bien dingue mais cela fonctionne et je peux jouer avec le BLACK_AND_WHITE_TRESHOLD pour changer son comportement.
+
+J'ai dabord testé avec un treshold de 100 et le programme a réussi à me sortir Tsunoda en deux mots ce qui était déja très encourageant. 
+
+Et après avoir augmenté le Treshold... Tada :
+
+!["Tsunoda 1080P avec filtre"](./Images/Screens/TextRecognition4.png)
+
+Le programme arrive bien à reconnaitre TSUNODA. Je pense que cette tactique ne fonctionnait pas avant car la resolution était trop faible et l'aliasing se mêlait trop avec le texte pour être utilisable.
+
+Cependant cette technique ne fonctionne pas sur tous les noms. Par example avec Leclerc :
+
+!["Leclerc 1080P avec filtre"](./Images/Screens/TextRecognition5.png)
+
+On récupère "Leeler'c" ce qui n'est pas bon du tout.
+
+Mais en modulant le Treshold (ici à 150) On peut de nouveau voir Leclerc être reconnu correctement
+
+!["Leclerc 1080P avec filtre 2"](./Images/Screens/TextRecognition6.png)
+
+Je pense que pour avoir de bons résultats il va falloir faire un algo qui :
+
+- Découpe l'image en autant de plus petites images pour avoir un mot par image.
+- Teste voir si avec l'image originale un nom correspond à la liste de pilotes existant.
+- Si cela ne marche pas, on applique le filtre en modulant le Treshold.
+- Dans le cas ou on aurait pas un match parfait on fait un algo qui cherche le nom le plus proche qui existe dans la liste de noms donnés.
+
+Seulement voila, il n'y a pas que des lettres que l'on veut récupèrer. On veut surtout pouvoir récupèrer les chiffres.
+
+Pour les chiffres on va avoir des soucis également...
+
+Si on essaie directement la même technique sans filtre on a des résultats comme celui ci :
+
+!["Tentative de reconnaisance du timing"](./Images/Screens/TimingRecognition0.png)
+
+La virgule a tendeance à se barrer ce qui est particulièrement problématique. Cependant comme les chiffres ont beaucoup moins de possibilitées que les lettres et qu'il n'y a pas de problème de langue on devrait pouvoir travailler à faire des règlage que l'on pourra ensuite utiliser.
+
+Avec un Treshold de 165 on arrive presque à quelque chose d'intéressant :
+
+!["Tentative 2 de reconnaissance du timing"](./Images/Screens/TimingRecognition1.png)
+
+Le + n'est clairement pas compris mais ca n'est pas embêtant car c'est souvent redondant. On arrive cependant à isoler 3 et 259. Même si la virgule n'est pas comprise cela veut dire qu'il est tout de même possible de discriminer les secondes des milisecondes.
+
+Maintenant avec un temps au tour :
+
+!["Reconnaissance du timing au tour"](./Images/Screens/TimingRecognition2.png)
+
+On arrive sans rien changer aux paramêtres à isoler minutes secondes et milisecondes. 
+
+Il semble que la reconnaissance de chiffre soit bien plus efficace que la reconnaissance de lettres. Il va falloir faire un test à plus grande échelle avec plus d'image pour se rendre compte de la precision.
+
+Demain ce qui serait bien cela serait que je fasse un jeu d'images avec des valeurs connues et que je fasse une batterie de tests pour voir à quel point je peux faire confiance à la reconnaissance des chiffres.
+
+Automatiser un système de test de la sorte me sera très utile dans le futur pour vérifier la non regression de ma reconnaissance de texte quand je tenterai d'y faire des changements.
+
+Je suis toujours curieux cependant de voir comment le programme se débrouille avec les nombres de tours qui se trouvent dans les icones de pneus. 
+
+# Journal de bord
+
+## Mercredi 29 Mars 2023
+
+----
+
+Premier jour du travail de diplôme. Nous avons eu un briefing de mr Garcia et nous avons pu commencer à préparer le travail.
+
+Nous avons eu les différents fichiers nescessaires à la bonne réalisation du projet et je me suis mis à faire les fichiers nescessaires
+
+La première chose a été de faire ce mkdocs dans lequel j'ai mis un fichier yml plutôt standart qui risque de changer au fur et à mesure.
+
+Voici le premier yml :
+
+```
+site_name: Documentation Diplome
+theme:
+        name: material
+        palette:
+        # Palette toggle for light mode
+        - media: "(prefers-color-scheme: light)"
+          scheme: default
+          toggle:
+          icon: material/brightness-7
+          name: Switch to dark mode
+
+        # Palette toggle for dark mode
+        - media: "(prefers-color-scheme: dark)"
+          scheme: slate
+          toggle:
+          icon: material/brightness-4
+          name: Switch to light mode
+markdown_extensions:
+  - attr_list
+  - md_in_html
+plugins:
+  - glightbox
+  - with-pdf
+```
+
+Voici un example de à quoi ca ressemble en forme de site
+
+!["Exemple mkdocs"](./Images/Screens/MkdocsExample.png)
+
+Ensuite il m'a fallu faire une version plus à jour de mon cahier des charges car je n'y avait pas touché depuis novembre. J'ai envoyé un mail à mes enseignants pour qu'ils puissent y jeter un oeuil pour être sûr que je n'ai rien changé qui les dérangent.
+
+Monsieur Jayr m'a demadé à l'occasion de lui faire un planning type Gantt alors je me suis mis à la tâche.
+
+J'ai fait un planning prévisionnel et une légende les deux sont dispo dans le dossier planning de ce repertoire.
+
+Ensuite je me suis mis à tout mettre sur git. A commencer par ce repertoire

docs/rapport.md

@@ -0,0 +1,85 @@
+# Rapport Track Trends V1.0
+
+
+----
+
+
+## Introduction
+
+
+----
+
+
+## Cahier des charges
+
+
+----
+
+
+## Différences sur le cahier des charges
+
+
+----
+
+
+## Planning prévisionnel
+
+
+----
+
+
+## Planning effectif et différences
+
+
+----
+
+
+## Analyse fonctionnelle
+
+
+----
+
+
+## Analyse Organique
+
+
+----
+
+
+### Récupération des images
+
+
+### Lecture des images
+
+
+### Interprétation des données
+
+
+### Stockage des données
+
+
+### Affichage des données
+
+
+### Prédictions
+
+
+## Tests
+
+
+----
+
+
+## Résumé des difficultés techniques
+
+
+----
+
+
+## Amélioration future
+
+
+----
+
+
+## Conclusion