Une bibliothèque pour .NET, calquée sur Processing

Présentation

Net.Processing se veut une bibliothèque offrant des possibilités graphiques simples suivant le modèle offert par Processing (www.processing.org), mais adapté aux standards C#/.NET. Net.Processing est si semblable que la documentation de Processing (www.processing.org/reference) est très utile pour en apprendre plus sur Net.Processing (voir référence rapide).

La principale différence avec Processing est que Net.Processing travaille avec des entiers (int) pour la plupart des paramètres de position et de taille (Processing travaille en float, mais n'oblige pas les suffixes « f » aux valeurs littérales, contrairement à ce qu'il faudrait en C#).

La plupart du temps, comme on travaille en pixel, l'emploi des entiers est plus naturel et plus simple. Par contre, lors de certains calculs, il faudra penser aux conversions réels-entiers, aux arrondis, etc. Une bonne chose à maîtriser et c'est pourquoi Net.Processing est fait ainsi (on peut utiliser des variables double ou float à l'intérieur du programme, si c'est utile, et les convertir lors de leur emploi en tant que paramètres). Une version de Net.Processing tout en double est prévue.

L'autre différence majeure est au niveau des identificateurs : la plupart des identificateurs utilisés par Processing commencent par une minuscule (rect(...), size(...), etc.) alors qu'ils commencent par une majuscule dans Net.Processing (Rect(...), Size(...), etc.). Les noms des constantes de Processing sont en majuscules (CENTER, LEFT, PIE, ARROW, etc.) : avec Net.Processing on peut utiliser ces noms directement, mais peut aussi utiliser une version en enum plus naturelle en C# (Parameter.Center, Parameter.Left, ArcStyle.Pie, MouseCursor.Arrow, etc.).

Différences spécifiques permanentes, à cause des différences techniques de C#/.NET :

Le type booléen s'appelle bool et non boolean.
on n'a pas de méthode Color(...), il faut faire new Color(...);¹
on ne peut pas spécifier directement les couleurs en hexadécimal avec #, mais on peut les mettre en string (par exemple "#4C12A6");
la variable/propriété frameRate s'appelle FrameRateValue. FrameRate() est la méthode pour changer la valeur;²
les variables/propriétés mousePressed et keyPressed s'appelle IsMousePressed et IsKeyPressed. MousePressed() et KeyPressed() sont les méthodes pour détecter des opérations de la souris ou du clavier;²
le niveau n'a aucun effet dans Smooth(niveau);
les codes de touches (pour KeyCode) commencent par KC_ (par exemple KC_DOWN). Ils sont plus complets que ceux de Processing.

Notez que, dans plusieurs cas, on peut dire que c'est Processing qui offre des possibilités discutables :
¹ En C#, on ne peut pas avoir une méthode du même nom qu'une classe.
² En C#, on ne peut pas avoir une propriété ou champ du même nom qu'une méthode.

Différences spécifiques sujettes à changement dans les prochaines versions de Net.Processing :

ColorMode() existe mais n'est pas fonctionnelle, on reste toujours en mode RGB;
LoadImage() n'accepte pas d'URL;
les images en format TGA ne sont pas supportées;
plusieurs autres méthodes ou classes, moins utiles ou trop avancées, n'existent pas dans Net.Processing. Il y a une liste ici. Certaines pourraient ne jamais être ajoutées à Net.Processing, en particulier, les méthodes ayant un équivalent général en C#/.NET et celles ayant rapport au 3D.

Net.Processing ajoute la possibilité de supplanter MouseDoubleClicked(), afin de pouvoir détecter les double-clics.

Contrairement à Processing, Net.Processing permet en tout temps l'interaction complète (lecture, écriture) avec la console, qui est donc toujours ouverte au départ en plus de la fenêtre graphique. La méthode HideConsole() permet de masquer la console si on le désire, mais elle réapparaitra si le programme essaie d'y lire une valeur. On peut éliminer complètement la console en changeant le type de projet pour Windows Application.

Pour simplifier la prise en main, Net.Processing offre des méthodes ReadConsoleInt(), ReadConsoleString() , ReadConsoleDouble() et ReadConsoleChar(), pour lire des données de la console (avec validation quand applicable). Il ajoute aussi une méthode Truncate() pour compléter Round(), Floor() et Ceil().

Préparation et utilisation

Pour utiliser Net.Processing :

Télécharger Net.Processing ici. Décompresser le fichier NetProcessing.zip afin d'obtenir NetProcessing.dll et NetProcessing.xml.
Créer un projet console.
Copier les fichiers NetProcessing.dll et NetProcessing.xml dans le dossier du projet (où est le fichier .csproj).
Ajouter une référence vers le fichier NetProcessing.dll (clic-droit sur References, Add Reference, Browse).
On peut ajouter un using NetProcessing; mais dans plusieurs programmes on n'aura à écrire NetProcessing qu'une seule fois.
Ajouter la dérivation de NetProcessing.Sketch à la classe Program : « class Program : NetProcessing.Sketch » (ou class Program : Sketch si on a mis un using NetProcessing).
Dans Main(), appeler Start() : new Program().Start();
- Sans animation
  Ajouter la méthode NPMain() : taper « override » suivi d'une espace et choisir NPMain(). Voilà, on peut écrire du code dans NPMain() normalement...
- Avec animation
  Ajouter la méthode Draw() : taper « override » suivi d'une espace et choisir Draw(). On peut y écrire du code qui sera exécuté à répétition. On peut aussi ajouter la méthode Setup() (en override aussi) pour y mettre du code à exécuter une seule fois, avant les Draw().
- Dans les deux cas, il faut enlever les appels à base.NPMain(), base.Draw() ou base.Setup().
Faire exécuter les programmes sans debug (Start Without Debugging, Ctrl+F5)
On peut ajouter des classes au programme : la plupart des éléments de Net.Processing sont globaux (statiques) dans la classe Sketch. On peut donc appeler Sketch.Rect(...) de n'importe où (ou NetProcessing.Sketch.Rect(...) si on n'a pas de using). On peut aussi simplement mettre les nouvelles classes dans la classe Program (par exemple, à la fin) pour être dans sa portée, et celle de NetProcessing.Sketch, et ne pas avoir à écrire Sketch ni NetProcessing.Sketch en préfixe.

Exemples de programmes traduits pour Net.Processing

Programme Processing sans animation et version Net.Processing/C# (les using sont inutiles, mais ne nuisent pas) :

size(800, 600);                                              using System;
fill(255, 0, 0);                                             using System.Collections.Generic;
rect(200, 200, 100, 200);                                    using System.Linq;
fill(#40FF00);
ellipse(250, 250, 100, 100);                                 namespace SansAnimation
                                                             {
                                                                 class Program : NetProcessing.Sketch
                                                                 {
                                                                     static void Main(string[] args)
                                                                     {
                                                                         new Program().Start();
                                                                     }

                                                                     public override void NPMain()
                                                                     {
                                                                         Size(800, 600);
                                                                         Fill(255, 0, 0);
                                                                         Rect(200, 200, 100, 200);
                                                                         Fill("#40FF00");
                                                                         Ellipse(250, 250, 100, 100);
                                                                     }
                                                                 }
                                                             }

Programme Processing avec animation et version Net.Processing/C# (les using de base sont omis, on aurait pu les laisser) :

/**                                                                       namespace Pointillisme
 * Pointillism                                                            {
 * by Daniel Shiffman.                                                        class Program : NetProcessing.Sketch
 *                                                                            {
 * Mouse horizontal location controls size of dots.                               static void Main(string[] args)
 * Creates a simple pointillist effect using ellipses colored                     {
 * according to pixels in an image.                                                   new Program().Start();
 */                                                                               }

PImage img;                                                                       PImage img;
int smallPoint, largePoint;                                                       int smallPoint, largePoint;

void setup() {                                                                    public override void Setup() 
  size(640, 360);                                                                 {
  img = loadImage("moonwalk.jpg");                                                    Size(640, 360);
  smallPoint = 4;                                                                     img = LoadImage("moonwalk.jpg");
  largePoint = 40;                                                                    smallPoint = 4;
  imageMode(CENTER);                                                                  largePoint = 40;
  noStroke();                                                                         ImageMode(CENTER);  // Ou ImageMode(Parameter.Center);
  background(255);                                                                    NoStroke();
}                                                                                     Background(255);
                                                                                  }

void draw() {                                                                     public override void Draw() 
  float pointillize = map(mouseX, 0, width, smallPoint, largePoint);              {
  int x = int(random(img.width));                                                     int pointillize = Truncate(Map(MouseX, 0, Width, smallPoint, largePoint)); // *
  int y = int(random(img.height));                                                    int x = Truncate(Random(img.Width));                                       // * 
  color pix = img.get(x, y);                                                          int y = Truncate(Random(img.Height));                                      // *
  fill(pix, 128);                                                                     Color pix = img.Get(x, y);
  ellipse(x, y, pointillize, pointillize);                                            Fill(pix, 128);
}                                                                                     Ellipse(x, y, pointillize, pointillize);
                                                                                  }
                                                                              } // * Dans tous ces exemples, on pourrait écrire Int(x) au lieu de Truncate(x)
                                                                          }