Ici on va « s’amuser » à créer des images en langage C

    On utilise la redirection sous unix/linux pour créer nos fichiers image .pbm

    🕒 : 3 h maximum

    Prérequis

    • TP7_C imagepbm image pbm machine linux (ubuntu, debian…) 
    • langage C , bases, les chars, les tableaux de chars.
    • imagemagick
    • redirections sous linux
    • Makefile 
    • Monia
    • Savoir coder en C , les bases

    But

    • Découverte d’un dépot git ici sur github
    • Dessiner dans une image N&B
    • utiliser make et Makefile
    • Comprendre les pixels noirs et les pixels blanc dans le format pbm ASCII

    Répertoire de travail :

    Le répertoire de travail sera ~/Works/TP7_C_PBM/imagepbm_V1

    Présentation

    Cours sur le format pbm 

    Nous allons travailler sur le code précédent , image blanche 800 X 600

    Découverte de Github et code de base

    Dépôt de code :

    https://github.com/CielaCode/pbm_V1.git

    Il faut les outils git pour utiliser github sur votre poste. (git est une création de Linus Torvald)

    sudo apt update &&  sudo apt install git -y

    dans votre répertoire de travail ~/Works/imagepbm

    git clone https://github.com/CielaCode/pbm_V1.git

    on a créé un « clone » du code sur votre machine .

    #Actuellement vous avez donc un répertoire projet du nom de pbm_V1
etudiant@ordi:~/Works/TP7_C_PBM/imagepbm_V1$ tree
.
└── pbm_V1
    ├── Makefile
    └── pbm_V1.c

2 directories, 2 files
etudiant@ordi:~/Works/TP7_C_PBM/imagepbm_V1$

    pbm_V1 ,l’ exécutable du projet obtenu en tapant la commande make 

    fichier Makefile :  permettant de générer le projet à l’aide de la commande make

    TARGET = pbm_V1
CFLAGS = -g -Wall -pedantic -ansi
CC = gcc
DEB = gdb

# Cible par défaut
all: $(TARGET)

$(TARGET): $(TARGET).c
	$(CC) $< $(CFLAGS) -o $@

edit: $(TARGET).c
	vi $(TARGET).c

gdb: $(TARGET)
	$(DEB) ./$(TARGET)

run: $(TARGET)
	./$(TARGET)

clean:
	rm -f $(TARGET)

.PHONY: all edit gdb run clean

    fichier source c :  pbm_V1.c

    /******************************************/
/** projet : pbm_V1                      **/
/** Image blanche de 800 x 600           **/
/** V1.Bogt2026 Lt Caroline Dorian       **/
/**                       17/10/2026     **/
/******************************************/
#include<stdio.h>
#include<stdlib.h>

int main()
{
int compteur;
/* en tete de l'image */
   printf("P1\n");  /* nombre magique voir wiki */
   printf("# image blanche réalisée avec pbm_V1\n");  /* commentaire du fichier */
   printf("800 600\n");  /* dimension de l'image */
/* boucle pour la génération des 480000 (800x600) pixels */
   for (compteur=0;compteur<800*600; compteur++)
       printf("0\n");
return EXIT_SUCCESS;
}
/*  faire un fichier pbm avec ce qui s'affiche */
/* ./pbm_V1 > image.pbm  */

    Créons des images

    A partir de maintenant il faudra créer votre Makefile dans vos projets (pbm_V1) et les autres .

    une image blanche de 800 x 600

    dans un répertoire   imgblc  réaliser le projet suivant.

    il faut s’aider du travail précèdent. (sur l’exemple suivant on a réalisé le répertoire imgblc) 

    etudiant@ordi:~/Works/TP7_C_PBM/imagepbm_V1$ tree
.
├── imgblc
└── pbm_V1
    ├── Makefile
    └── pbm_V1.c

3 directories, 2 files
etudiant@ordi:~/Works/TP7_C_PBM/imagepbm_V1$

    source :  imgblc.c 

    à compiler comme vous savez faire . (ici on a même un Makefile !)

    image blanche : imgblc

    ici pbm_V1 est ce qui est demandé (oui ca fait une image blanche de 800×600) ! mais il vous faudra adapter le code pour réaliser le code avec le nom imgblc .

    Exemple de ce que vous devez obtenir :

    etudiant@ordi:~/Works/TP7_C_PBM/imagepbm_V1$ tree
.
├── imgblc
│   ├── imgblc
│   ├── imgblc.c
│   ├── imgblc.pbm
│   └── Makefile
└── pbm_V1
    ├── image.pbm
    ├── Makefile
    ├── pbm_V1
    └── pbm_V1.c

    donner la commande pour compiler ce code.

    tester le code, 

    Comment récupérer le flux de caractère pour l’écran dans un fichier imgbc.pbm ?

    faire un fichier pbm avec ce qui s’affiche

    ./imgblc > imgblc.pbm  
file imgblc.pbm

    qui va nous donner les caractéristiques du fichier (file)

    regarder ensuite avec imagemagick (la commande display)

    display  imgblc.pbm

    oui regarder ce même fichier avec vi

    expliquer:

    Donner le pseudo code et l’organigramme de imgblc  (monia) et le Pseudo Langage

    image noire : imgnoire

    une image noire de 800 x 600

    dans un répertoire imgnoire réaliser le projet suivant. (toujours un Makefile et un code qui fonctionnera)

    à partir de l’exemple précédent donner un code qui donne une image noire.

    Donner le pseudo code et l’organigramme imgnoire (monia) et le Pseudo Langage

    Travaillons dans le plan, en 2 dimensions.

    un plan A B C D E F  pour les colonnes

    et  1 à 11 pour les lignes

    On a mis 2 points dans ce tableau , trouvez les 1 !

    Juste la pour expliquer comment on place des points noirs dans un tableau.

    une image est un plan d’éléments binaire (bitmap). (ici pour faire très simple 1 noire et 0 blanc)

    En C nous avons le tableau a 1 dimension  , une ligne: 66 caractères ,de A à F 6 colonnes et 11 lignes 6×11=66

    char ligne[66]

    cela représente  une ligne 66 caractères, indicé de 0 à 65

    une image est une succession de ligne non?

    char image[6][11]

    c’est un tableau de char (octet)   de 6 x 11 . (on a rajouté une dimension , nous ne sommes plus sur une ligne mais dans un tableau)

    On imagine très bien que c’est notre image  sur cet exemple pédagogique !

    Et la nous allons augmenter la taille de notre image 800 x600

    /******************************************/
/** Image avec points de 800 x 600       **/
/** V1.Bogt2020 LtDorian		 **/
/**                       09/11/2020	 **/
/******************************************/
#include<stdio.h>
#include<stdlib.h>
#define largeur 800
#define hauteur 600
char image[largeur][hauteur];  /* representation de notre image */
int main()

{
       int x,y;
/* remplir le tableau de '0' pour faire une image blanche */
       for (y=0; y <hauteur ; y++) /* pour toutes les lignes */	
           for (x=0; x<largeur ; x++) /* pour chaque colonnes */
	   image[x][y]='0';   /* mettre un pixel blanc */
/* on place un point sur l'image coordonnées 320,456 */
image[320][456]='1';  /* il suffit de mettre un 1 dans la bonne case ! */
/* on place un point sur l'image coordonnées 501,322 */
image[501][322]='1';
/*Afficher l'image Pbm en ASCII*/
/* en tete de l'image */
       printf("P1\n");
/* pas de commentaire */
/* on donne les coordonnées en décimal dans l’entête */
       printf("%d %d\n",largeur,hauteur);
/* on place tous les pixels */
       for (y=0; y <hauteur ; y++) /* pour toutes les lignes */	
           for (x=0; x<largeur ; x++) /* pour chaque colonnes */
	   printf ("%c \n",image[x][y]);
return EXIT_SUCCESS;
}
/*  faire un fichier pbm avec ce qui s'affiche */
/* ./bitmap > bitmap.pbm  */

    Avez vous vu les 2 points ???

    cross (croix) . Ajoutons des axes X et Y

    Dans un projet cross , écrire un code cross.c et son Makefile

    on désire dessiner  des axes (une croix)  sur notre image.

    pt1 (399,0) à  pt2 (399,599) pour l’axe X

    pt3 (0,299) à pt4 (799,299)

    pour avoir cette image on peut remplir à la main chaque pixel …

    image[399][0]='1';
image[399][1]='1';
image[399][2]='1';
...
etc
image[399][799]='1';

    franchement on a inventer l’ordinateur pour ne pas faire ce genre de tâches fastidieuses trouver une solution autre pour réaliser les axes.

    proposer une solution

    Donner un code avec son pseudo code et son organigramme (monia)

    , pour comparer à votre solution , git : https://github.com/CielaCode/cross.git

    /******************************************/
/** projet : cross                       **/
/** Image blanche de 800 x 600 et axes   **/
/** V1.Bogt2026 Lt Caroline Dorian       **/
/**                       17/10/2026     **/
/******************************************/
#include<stdio.h>
#include<stdlib.h>

#define DIMX 800    /* macros */
#define DIMY 600

/* variable globale de l'image */
char image [DIMX][DIMY];

int main()
{
/* variables locales du main */
int compteur_x; /*0 à 799 */
int compteur_y; /*0 à 599 */
/* en tete de l'image */
       printf("P1\n");   /* nombre magique */
/* pas de commentaire */
       printf("%d %d\n",DIMX,DIMY);

/* génération des DIMX x DIMY pixels blancs */
   /* on a rempli de blanc '0' */
   for (compteur_y=0; compteur_y<DIMY ; compteur_y++)
       {
       for (compteur_x=0; compteur_x<DIMX ; compteur_x++)
           {
           image[compteur_x][compteur_y]='0';
           }
       }

/* axe horizontal */
   for (compteur_x=0; compteur_x <DIMX ; compteur_x++)
          image[compteur_x][DIMY/2]='1';

/* axe vertical*/
    for (compteur_y=0; compteur_y <DIMY ; compteur_y++)
          image[DIMX/2][compteur_y]='1';

/* on affiche les pixels en pacourant le tableau image */    
    for (compteur_y=0; compteur_y<DIMY ; compteur_y++)
    {
        for (compteur_x=0; compteur_x<DIMX ; compteur_x++)
            {
                printf("%c\n",image[compteur_x][compteur_y]);
            }
    }
return EXIT_SUCCESS;
}
/*  faire un fichier pbm avec ce qui s'affiche */
/* ./cross > cross.pbm  */

    Makefile 

    TARGET = cross
CFLAGS = -g -Wall -pedantic -ansi
CC = gcc
DEB = gdb

# Cible par défaut
all: $(TARGET)

$(TARGET): $(TARGET).c
	$(CC) $< $(CFLAGS) -o $@

edit: $(TARGET).c
	vi $(TARGET).c

gdb: $(TARGET)
	$(DEB) ./$(TARGET)

run: $(TARGET)
	./$(TARGET)

clean:
	rm -f $(TARGET)

.PHONY: all edit gdb run clean