processing écrire un texte Archives

Sommaire :

2020/01/05 : Création d’un cercle point par point sur Processing
2017/09/03 : Processing – Arduino – Animation d’une forme
2017/07/27 : Tuto comment utiliser l’entrée son
Retour au menu Vidéo

Création d’un cercle point par point sur Processing

Simulation d’un laser rotatif type lidar ( sur un 1 axe ) en 3 etapes

Etape 3.1 : Traçage d’un cercle point par point
Etape 3.2 : Création d’une variable modifiant les valeurs de rayon.
Etape 3.3 : Création d’un cercle point par point avec déplacement .

2017/09/03 : Processing – Arduino . Animation d’une forme

La communication série – Lecture de 3 valeurs sur la carte Arduino via le port série et animation d’un rectangle sur l’écran . Les programmes Arduino et Processing

Retour au sommaire

2017/07/27 : Tuto comment utiliser l’entrée son

Comment récupérer une source sonore sous Processing
Au sommaire : Intégration de la bibliothèque/Configuration de la fonction minim/Mise à l’échelle de la valeur sonore/Utilisation de la valeur

Retour au sommaire

Le langage Processing : écrire un texte dans l’espace de travail

–

Mise à jour le 08/07/2017

Sommaire :

Le langage Processing sur l’utilisation du texte dans l’espace de travail .
- 001- Exemple pour écrire un texte sur l’écran avec , choix de la couleur du texte , de la taille , du positionnement du texte et enfin le contenu.
- 004 – La typographie comment importer une police de caractères
- 010- Comment déplacer un texte avec la commande translate sans effacement de l’ancienne position

Retour au sommaire

001 – Exemple pour écrire un texte sur l’écran avec , choix de la couleur du texte , de la taille , du positionnement du texte et enfin le contenu .

Exemple de programme :

//
//
// Exemple ecrire un texte sur l'ecran 
// 
// Choisir la couleur du texte
// choisir la taille du texte 
// Positionner le texte sur l'ecran et donner le contenue du texte
//
// H-Mazelin 23/06/2017


// La fonction setup () est exécutée une fois, lorsque le programme démarre. 
// Il sert à définir les propriétés d'environnement initiales telles que la 
// taille de l'écran et à charger des supports tels que des images et des polices
// au démarrage du programme. 


void setup ()
{
  // definition de la taile de la fenetre 
  // syntaxe : size (Hauteur fenetre,largeur fenetre )
  size(1000,800);
  
  
  
  
}


//Le programme principal s’exécute par une boucle infinie appelée draw () 
void draw ()
{

  // choix de la couleur du fond de la fenetre 
  // syntaxe : background (rouge,vert,bleu )
  // valeur du rouge de 0 à 255 iden pour les autre couleurs
  // affichage du fond de l'ecran en blanc 
  background(255,255,255); 
  
  // Fill : Définit la couleur utilisée pour remplir les formes.
  // fill(r,g,b);
  // r = pour rouge
  // g = pour le vert
  // b = pour le bleu
  fill(0,0,0);
  
  // Choix de la taille de la police 
  // syntaxe => textSize( taille )
  // Taille => La taille des caractères est en de pixels.
  textSize(32);
  
  // Affichage d'un texte à l'écran
  // text (texte,x,y);
  // x => coordonnée x du texte
  // y => coordonnée y du texte 
  text("Bonjour de l'équipe RedOhm ", 220, 75);
  
  // Choix de la taille de la police 18 pixels
  textSize(18);
  // Affichage d'un texte à l'écran
  text("Bienvenue sur RedOhm.fr ", 15, 150);
  
  // Choix de la taille de la police 15 pixels
  textSize(15);
  // Affichage d'un texte à l'écran
  text("Nous sommes une équipe de passionnés de robotique, électronique, ", 15, 190);
  text("mécanique et nous partageons ici le fruit de notre travail.", 520, 190);
  

  
  
}

// Exemple ecrire un texte sur l'ecran

// Choisir la couleur du texte

// choisir la taille du texte

// Positionner le texte sur l'ecran et donner le contenue du texte

// H-Mazelin 23/06/2017

// La fonction setup () est exécutée une fois, lorsque le programme démarre.

// Il sert à définir les propriétés d'environnement initiales telles que la

// taille de l'écran et à charger des supports tels que des images et des polices

// au démarrage du programme.

void setup ()

{

// definition de la taile de la fenetre

// syntaxe : size (Hauteur fenetre,largeur fenetre )

size(1000,800);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw ()

{

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 iden pour les autre couleurs

// affichage du fond de l'ecran en blanc

background(255,255,255);

// Fill : Définit la couleur utilisée pour remplir les formes.

// fill(r,g,b);

// r = pour rouge

// g = pour le vert

// b = pour le bleu

fill(0,0,0);

// Choix de la taille de la police

// syntaxe => textSize( taille )

// Taille => La taille des caractères est en de pixels.

textSize(32);

// Affichage d'un texte à l'écran

// text (texte,x,y);

// x => coordonnée x du texte

// y => coordonnée y du texte

text("Bonjour de l'équipe RedOhm ", 220, 75);

// Choix de la taille de la police 18 pixels

textSize(18);

// Affichage d'un texte à l'écran

text("Bienvenue sur RedOhm.fr ", 15, 150);

// Choix de la taille de la police 15 pixels

textSize(15);

// Affichage d'un texte à l'écran

text("Nous sommes une équipe de passionnés de robotique, électronique, ", 15, 190);

text("mécanique et nous partageons ici le fruit de notre travail.", 520, 190);

}

–

Retour au sommaire

Menu langage Processing

004 – La typographie comment importer une police de caractères

–

Tutoriel comment importer une police de caractères .( Pour visionner ce tutoriel cliquez sur « agrandir » et attendez quelques secondes)

–

Exemple de programme :

//
//
//***************************************************************************
// RedOhm
//
// La typographie
// Comment importer une police de caractéres 
//
// Le 06/07/2017
// H-Mazelin
//
//***************************************************************************

// La fonction PFont indique à Processing le genre de la variable et lui 
// permettra d'ouvrir assez de mémoire pour contenir l'ensemble des données
// de ce genre

PFont police; 
 
// La fonction setup () est exécutée une fois, lorsque le programme démarre. 
// Il sert à définir les propriétés d'environnement initiales telles que la 
// taille de l'écran et à charger des supports tels que des images et des polices
// au démarrage du programme. 


void setup()
{
 
  
 
 // definition de la taille de la fenetre 
 // syntaxe : size (Hauteur fenetre,largeur fenetre )
 size(800,600); 
 
 // choix de la couleur du fond de la fenetre 
 // syntaxe : background (rouge,vert,bleu )
 // valeur du rouge de 0 à 255 iden pour les autre couleurs
 // affichage du fond en gris 
 background(209,209,209);  
  
 // Fill : Définit la couleur utilisée pour remplir les formes.
 // fill(r,g,b);
 // r = pour rouge
 // g = pour le vert
 // b = pour le bleu
 fill(0,0,0);
 textSize(32);
 text("La typographie",280,50);
 textSize(20);
 text("Comment importer une police de caractéres sur Processing",100,100); 
}


//Le programme principal s’exécute par une boucle infinie appelée draw () 
 
void draw()

{
 
 // ********************* importer une police 1 ************************ 
 // on charge le type de police 
 police = loadFont("Magneto-Bold-48.vlw");
 // Cette fonction  rend la police active.avec la hauteur de la police 
 textFont(police,30);
 // Fill : Définit la couleur utilisée pour remplir les formes.
 // fill(r,g,b);
 // r = pour rouge
 // g = pour le vert
 // b = pour le bleu
 fill(255,0,0);
 // Affichage d'un texte à l'écran
 // dans notre exemple  -> redohm en couleur rouge 
 // la position du texte à l'ecran en x 
 // la position du texte à l'ecran en y
 text(" redohm en couleur rouge ",20,340);
}

//***************************************************************************

// RedOhm

// La typographie

// Comment importer une police de caractéres

// Le 06/07/2017

// H-Mazelin

//***************************************************************************

// La fonction PFont indique à Processing le genre de la variable et lui

// permettra d'ouvrir assez de mémoire pour contenir l'ensemble des données

// de ce genre

PFont police;

// La fonction setup () est exécutée une fois, lorsque le programme démarre.

// Il sert à définir les propriétés d'environnement initiales telles que la

// taille de l'écran et à charger des supports tels que des images et des polices

// au démarrage du programme.

void setup()

{

// definition de la taille de la fenetre

// syntaxe : size (Hauteur fenetre,largeur fenetre )

size(800,600);

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 iden pour les autre couleurs

// affichage du fond en gris

background(209,209,209);

// Fill : Définit la couleur utilisée pour remplir les formes.

// fill(r,g,b);

// r = pour rouge

// g = pour le vert

// b = pour le bleu

fill(0,0,0);

textSize(32);

text("La typographie",280,50);

textSize(20);

text("Comment importer une police de caractéres sur Processing",100,100);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw()

{

// ********************* importer une police 1 ************************

// on charge le type de police

police = loadFont("Magneto-Bold-48.vlw");

// Cette fonction rend la police active.avec la hauteur de la police

textFont(police,30);

// Fill : Définit la couleur utilisée pour remplir les formes.

// fill(r,g,b);

// r = pour rouge

// g = pour le vert

// b = pour le bleu

fill(255,0,0);

// Affichage d'un texte à l'écran

// dans notre exemple -> redohm en couleur rouge

// la position du texte à l'ecran en x

// la position du texte à l'ecran en y

text(" redohm en couleur rouge ",20,340);

}

Retour au sommaire

Menu langage Processing

010 – Comment déplacer un texte avec la fonction translate sans effacement de l’ancienne position

Exemple de programme :

//
// Comment déplacer un texte avec la commande translate
// sans effacement de l'ancienne position 
//
// H-Mazelin le 12/06/2017 


 // Declare la variable X 
 // Rappel sur la fonction d'une variable :On peut définir une variable comme
 // une boite ou l’on stock des balles .Une variable est une boite ou 
 // l’on stock un nombre ,et comme il existe une multitude de nombres:
 // Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette
 // variable .
 int x;



// La fonction setup () est exécutée une fois, lorsque le programme démarre. 
// Il sert à définir les propriétés d'environnement initiales telles que la 
// taille de l'écran et à charger des supports tels que des images et des polices
// au démarrage du programme. 




void setup ()
{
  // definition de la taile de la fenetre 
  // syntaxe : size (Hauteur fenetre,largeur fenetre )
  size(1000,600);
  // choix de la couleur du fond de la fenetre 
  // syntaxe : background (rouge,vert,bleu )
  // valeur du rouge de 0 à 255 iden pour les autre couleurs
  background(255,255,255);
  
}


//Le programme principal s’exécute par une boucle infinie appelée draw () 
void draw ()

{
  
// Boucle comptant de 0 a 10 avec un increment de 1
// for (initialisation ; condition ; increment)
// entre crochet { instructions executees dans la boucle }
  
for (x=0;x<10;x++)  
 {
   
    // Fill : Définit la couleur utilisée pour remplir les formes.
    // Syntaxe => fill(r,g,b);
    // r = pour rouge
    // g = pour le vert
    // b = pour le bleu  
    fill(0);
 
    // translate => permet de faire une translation au système de coordonnées
    // Cette fonction est additionnelle et s'appliquent à tout ce qui se passe 
    // dans une boucle comme dans notre exemple 
    // est donc la fonction accumulent l'effet.
    // Syntaxe translate (x,y);
    // x => deplacer la coordonnée de gauche vers la droite
    // y => deplacer la coordonnée du haut vers le bas 
    translate(20,20);
 
    // Affichage d'un texte à l'écran
    // Syntaxe => text (texte,x,y);
    // x => coordonnée x du texte
    // y => coordonnée y du texte 
    text("RedOhm 2017",0,0);
 
 }
 
 
  
}

// Comment déplacer un texte avec la commande translate

// sans effacement de l'ancienne position

// H-Mazelin le 12/06/2017

// Declare la variable X

// Rappel sur la fonction d'une variable :On peut définir une variable comme

// une boite ou l’on stock des balles .Une variable est une boite ou

// l’on stock un nombre ,et comme il existe une multitude de nombres:

// Exemple entiers ,décimaux etc …Il faut donc assigner un type à cette

// variable .

int x;

// La fonction setup () est exécutée une fois, lorsque le programme démarre.

// Il sert à définir les propriétés d'environnement initiales telles que la

// taille de l'écran et à charger des supports tels que des images et des polices

// au démarrage du programme.

void setup ()

{

// definition de la taile de la fenetre

// syntaxe : size (Hauteur fenetre,largeur fenetre )

size(1000,600);

// choix de la couleur du fond de la fenetre

// syntaxe : background (rouge,vert,bleu )

// valeur du rouge de 0 à 255 iden pour les autre couleurs

background(255,255,255);

}

//Le programme principal s’exécute par une boucle infinie appelée draw ()

void draw ()

{

// Boucle comptant de 0 a 10 avec un increment de 1

// for (initialisation ; condition ; increment)

// entre crochet { instructions executees dans la boucle }

for (x=0;x<10;x++)

{

// Fill : Définit la couleur utilisée pour remplir les formes.

// Syntaxe => fill(r,g,b);

// r = pour rouge

// g = pour le vert

// b = pour le bleu

fill(0);

// translate => permet de faire une translation au système de coordonnées

// Cette fonction est additionnelle et s'appliquent à tout ce qui se passe

// dans une boucle comme dans notre exemple

// est donc la fonction accumulent l'effet.

// Syntaxe translate (x,y);

// x => deplacer la coordonnée de gauche vers la droite

// y => deplacer la coordonnée du haut vers le bas

translate(20,20);

// Affichage d'un texte à l'écran

// Syntaxe => text (texte,x,y);

// x => coordonnée x du texte

// y => coordonnée y du texte

text("RedOhm 2017",0,0);

}

Résultat du programme comment déplacer un texte avec la commande translate – RedOhm

Comment déplacer un texte avec la commande translate – RedOhm

Retour au sommaire

Menu langage Processing

Le langage pour Processing

.

Mise à jour le 25/12/2019 :Processing est tout particulièrement adapté à la création graphique interactive , mais sa simplicité d’utilisation en fait aussi aussi un bon support pour l’apprentissage de la programmation pour les non-programmeurs.

Continuer la lecture →