liriodendron 0.2.0

Procedural Pixellized 2D Textures Generator with TUI
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/