Net.Processing  1.3.0
Documentation
 Tout Classes Espaces de nommage Fonctions Variables Énumérations Valeurs énumérées Propriétés Pages
Net.Processing par Michel Michaud

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

ENGLISH VERSION.

Accéder à la documentation principale (classe NetProcessing.Sketch).

Accéder à la référence rapide.

Télécharger Net.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 :

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

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(), ReadConsoleDouble() et ReadConsoleChar(), pour lire des données de la console (avec validation). Il ajoute aussi une méthode Truncate() pour compléter Round(), Floor() et Ceil().

Création : Michel Michaud, décembre 2013 - septembre 2015 (version 1.3)
Copyright ©Michel Michaud

Préparation et utilisation

Pour utiliser Net.Processing :

  1. Télécharger Net.Processing ici. Décompresser le fichier NetProcessing.zip afin d'obtenir NetProcessing.dll et NetProcessing.xml.
  2. Créer un projet console.
  3. Copier les fichiers NetProcessing.dll et NetProcessing.xml dans le dossier du projet (où est le fichier .csproj).
  4. Ajouter une référence vers le fichier NetProcessing.dll (clic-droit sur References, Add Reference, Browse).
  5. On peut ajouter un using NetProcessing; mais dans plusieurs programmes on n'aura à écrire NetProcessing qu'une seule fois.
  6. 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).
  7. 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().
  8. Faire exécuter les programmes sans debug (Start Without Debugging, Ctrl+F5)
  9. 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)
                                                                          }

Net.Processing 1.3.0, par Michel Michaud ©2014-2015 (documentation version Mardi 8 Septembre 2015)