Travail académique de substitution au stage ------------------------------------------- Réalisé par Pablo TOMAS M2 Informatique parcours GL --------------------------------------------------------------------- ### Sujet: Générateur procedural de textures pixellisées en deux dimensions. --------------------------------------------------------------------- ### Motivation: Le sujet de ce travail académique est inspiré du logiciel Crypixels (https://crypixels.com/). Ayant déjà utilisé des technologies procédurales (Bruit de Perlin, domain warping et fractional brownian motion.) pour d’autres projets non liés à l’image et éprouvant un fort interêt pour ces technologies, il me vient la curiosité de les appliquer dans d’autres domaines. De plus, d’autres technologies comme les automates cellulaires ou les fractals que je n’ai pas encore eu l’occasion de découvrir, pourront m’aider dans la réalisation de nouvelles fonctionnalités ou dans la génération de textures. --------------------------------------------------------------------- ### Technologies envisagées: Le cadre de ce projet étant académique (et non professionnel), mon souhait est d’apprendre un nouveau langage. Je souhaite utiliser un langage de programmation me laissant le plus de contrôle possible sur mon implémentation. Étant des langages de plus en plus demandés sur la marché du travail et répondant au mieux à mes contraintes je pense utiliser soit le langage GoLang, soit le langage Rust. Le langage GoLang est d'une part facile à apprendre et simple à lire. Ce sont les deux principaux avantages que l'on retrouve assez regulièrement lorsqu'il est comparé au langage Rust. Cependant il n'est pas orienté programmation objet (il n'y a pas d'heritage) et il possède moins de frameworks que Rust. En plus de cela ajoutons que même s'il est plus facile à apprendre ce n'est pas vraiment un avantage puisque l'apprendre plus tard sera moins coûteux que d'apprendre le Rust. Réaliser ce logiciel avec Rust me fera bénéficier d'un plus grand nombre de framework. C'est également un langage de programmation sécurisé et qui facilite les procédures de tests et de débugging. Mon choix est donc d'utiliser le langage Rust pour ce projet. Pour rester sur le thème du pixel, je souhaiterai donner à l’interface utilisateur une esthétique rétro. Pour cela j’envisage de développer l’interface graphique sur terminal. J'envisage donc d'utiliser tui-rs et son backend crossterm-rs pour permettre à l'interface utilisateur d'être supporté autant par UNIX que Windows, image-rs pour la création de textures et noise-rs et rand-rs pour la partie procédurale de l'application. --------------------------------------------------------------------- ### Besoins fonctionnels: Le logiciel Crypixels propose les fonctionnalités suivantes qui me paraissent interessantes à implementer. Il me semble important de les séparer en deux catégories afin de distinguer leur priorités. Voici les fonctionnalités «basiques»: - Une grille de génération servant à définir la forme générale de la texture à génerer. Elle est par défaut remplie de pixels vides. - Un raccourci clavier «Generate» générant la(les) texture(s) en fonction de la grille de génération et des paramètres sélectionnés. - Une brosse sur la grille permettant de changer un pixel selectionné par: un pixel bordure (Pixel pouvant se trouver à côté de tout type de pixel même s’il est vide. Sa couleur est plus sombre que le pixel corps.), un pixel corps (Pixel ne pouvant pas se trouver à côté d’un pixel vide. Sa couleur est plus vive que celle d’un pixel bordure.), un pixel corps/vide (Pixel pouvant être soit un pixel vide, soit un pixel corps.), un pixel corps/bordure (Pixel pouvant être soit un pixel corps, soit un pixel bordure.), un pixel de couleur spécifique ou un pixel vide. - Un nombre de textures à générer (500 au maximum.). - Une option permettant de définir la taille de la grille (Par défaut 10x10). Voici les fonctionnalités «avancées»: - Des raccourcis clavier «Save» et «Load» pour sauvegarder et retrouver les paramètres de la grille de génération d’une session dans un format specifique. - Un paramètre de ratio pour les pixels (1 cellule sur la grille de génération représente combien de pixels pour la texture?). Par défaut 1 cellule = 4 pixel. Minimum: 1 cellule = 1 pixel. - Un paramètre permettant de selectionner le choix de format de la texture générée(PNG, JPG, ZIP). - Un raccourci clavier «Undo» et un bouton «Redo» pour modifier les actions déjà effectuées sur la grille de génération. - Un raccourci clavier «Clear Grid». - Une option «Mirror» permettant de rendre la texture symétrique verticalement et/ou horizontalement. - Un paramètre de ratio pour définir dans quelle mesure un pixel bordure est plus sombre qu’un pixel corps. - Un paramètre pour définir l'utilisation d'ombre sur la texture ou non. - Un paramètre pour définir la luminosité sur la texture. - Un paramètre pour définir l'intensité de l'ombre sur la texture. - Des paramètres pour modifier la génération pour les pixels corps/vide et corps/bordures: utilisation de quel procédé de génération (Perlin noise, Cellular Noise, Simplex Noise, Hasard, Automate Cellulaire, Fractal, domain warping, fractionnal brownian motion, pattern tiling.) et des options de paramétrisation propres à chacun d’entre eux. - Des paramètres pour modifier la génération pour les couleurs de la texture: utilisation de quel procédé de génération (Perlin noise, Cellular Noise, Simplex Noise, Hasard, Automate Cellulaire, Fractal, domain warping, fractionnal brownian motion, pattern tiling.) et des options de paramétrisation propres à chacun d’entre eux. - Des raccourcis claviers modifiables par l’utilisateur et les rétablir par défaut. - La possibilité de changer entre une vue centrée sur la grille que l'utilisateur est en train d'éditer et une vue centrée sur les paramètres de générations et les autres fonctionnalités de l'application A cela, ajoutons ces fonctionnalités qui ne sont pas présentes sur le logiciel Crypixels: - Un raccourci clavier pour ajouter une nouvelle grille de génération à l'espace de travail et génerer des textures à partir de plusieurs grilles de génération. - Un onglet représentant chaque grille de génération. Chaque onglet contient le nom de la grille (et peut donc être renommé) et un raccourci clavier pour supprimer la grille. - Des manivelles permettant de naviguer sur la grille de génération quelque soit la taille des grilles de génération sans encombrer l'espace de travail. - Un raccourci clavier «New» pour définir un nouvel espace de travail (grilles de générations et paramètres de génération) et effacer l'ancien. - Des ratios permettant de paramétrer les pixels corps/bordure et corps/vide. - Une option permettant de rendre la texture symétrique par rapport à un point prédefini. - Des choix prédéfinis d'ombres à appliquer sur la texture (circulaire, en forme de croix, verticale, horizontale, adaptée à la forme globale de la texture, diagonale 1, diagonale 2, croix en diagonale, gauche, bas, aucune...). - Une option pour inverser les endroits avec et sans ombres lorsqu'une ombre est selectionnée. - Un paramètre pour définir le nombre minimum et le nombre maximum de couleurs différentes pour la texture. - Un selecteur de couleur si l’utilisateur souhaitent choisir la (les) couleur(s) à utiliser pour la texture. - La possibilité d'implémenter sa propre méthode procédurale (bruit et automate cellulaires) en RUST. - Un paramètre sous la forme d'un coefficient pour zoomer/dézoomer les coordonnées des pixels en entrées de la fonction de génération. - Un paramètre sous la forme d'un vecteur à deux dimension pour décaler les coordonnées des pixels en entrées de la fonction de génération. - La possibilité de générer des animations procéduralement sur une seule texture. - La possibilité de paramétrer l'application pour qu'elle soit plus performante mais propose moins de possibilités (ou l'inverse). - La possibilité d'accéder à un tutoriel guidé. --------------------------------------------------------------------- ### Besoins non-fonctionnels: - Multiplateforme afin de permettre à l’utilisateur d’utiliser le générateur avec ce pour quoi l’utilisateur souhaite utiliser les textures (Photoshop, Adobe ou autres logiciels permettant de modifier des images, moteur de jeux, Instagram, Imgurou autres applications permettant d’exposer des images, ...). - Efficacité pour ne pas ralentir le materiel de l’utilisateur si celui-ci souhaite générer un nombre conséquent de textures. - Des textures au format compressé pour ne pas qu’elles occupent un espace abusivement volumineux sur le materiel de l’utilisateur. --------------------------------------------------------------------- ### Issues: Disponibles dans le dossier "issues". --------------------------------------------------------------------- ### Tasks: Disponibles ici: https://trello.com/b/2Cdyx6A2/liriodendron --------------------------------------------------------------------- ### Procédures de Test: Le langage de programmation Rust offre la possibilité d'effectuer des tests unitaires et d'integration avec Cargo et la commande "cargo test". Ces possibilités sont décrites dans le chapitre 12 du manuel d'utilisation "Rust Programming Language". Tous les tests unitaires sont présents dans "dev/". Ils sont présents dans chaque module de chaque crate. Les tests d'integrations sont disponibles dans "dev/tests". La méthode de developpement logiciel utilisée pour la réalisation des tests est la Test Driven Development (TDD). --------------------------------------------------------------------- ### Documentation: Le langage de programmation Rust offre la possibilité d'écrire une documentation avec Cargo et la commande "cargo doc --open". Ces possibilités sont décrites dans le chapitre 14.2 du manuel d'utilisation "Rust Programming Language". La documentation administrateur est disponible par utilisation de cette fonctionnalité. La documentation utilisateur est disponible dans le dossier "doc". --------------------------------------------------------------------- ### Releases: Disponibles ici: https://github.com/pabtomas/liriodendron/releases --------------------------------------------------------------------- ### Organisation: Première Release: - Semaine 1: Apprentissage de Rust, Planification des Sprints - Semaines 2, 3 & 4: Mise en place des fonctionnalités basiques + Mise en place de l'interface utilisateur + Tests + Documentation Deuxième Release: - Semaines 5, 6 & 7: Mise en place de certaines fonctionnalités avancées + Tests + Documentation - Semaine 8: Amélioration de l’existant Troisième Release: - Semaine 9, 10 & 11: Mise en place de certaines fonctionnalités avancées + Amélioration de l’existant + Tests + Documentation finale. --------------------------------------------------------------------- ### Bibliographie: Un premier algorithme permettant de generer des textures: http://web.archive.org/web/20080228054410/http://www.davebollinger.com/works/pixelspaceships/ Un algorithme permettant de générer des textures composées de plusieurs autres textures: http://davideyork.com/gengam-2016 Deux algorithmes permettant de generer une texture à partir d'un echantillon d'une autre texture: https://github.com/mxgmn/WaveFunctionCollapse http://inversed.ru/Blog_5.htm Un algorithme pour le choix des couleurs lors de la generation: http://devmag.org.za/2012/07/29/how-to-choose-colours-procedurally-algorithms/ Necessite encore un tri mais contient beaucoup d'information sous format PDF et certaines d'entres elles pourraient potentiellement être utilisées: http://www.procjam.com/seeds/ Un guide sur les generateurs: http://tinyurl.com/seedscompton Un livre dont certains chapitres pourraient être utilisés (sur les automates cellulaires, la personnalisation de la distribution de nombre aléatoires, les fonctions oscillantes, les fractals ...): https://natureofcode.com/ Un livre porté sur les jeux vidéos. Le chapitre 12 (dont je n'ai lu que l'absract et l'introduction) nommé: "Evaluating content generators by Noor Shaker, Gillian Smith, and Georgios N. Yannakakis" peut proposer des methodes applicables pour évaluer le générateur: http://pcgbook.com/