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

On utilise la redirection pour créer nos fichiers

🕒 : 3 h maximum

Le répertoire de travail sera ~/Works/L2PBM

Prérequis

TP L1 image pbm machine linux (ubuntu, debian…)
langage C , bases, les chars, les tableaux de chars.
imagemagick
redirections sous linux
Makefile

But

Dessiner dans une image N&B

Présentation

Cours sur le format pbm

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

Dans un répertoire ~/Works/L2PBM/imagepbm

Découverte de Github

Dépôt de code

https://github.com/CarolineDorian/l2pbm

Il faut les outils github sur votre poste.

sudo apt update &&  sudo apt install git -y

au lycée on a un proxy à traverser :

# réglage du proxy pour l'utilisation de git (pour github) au lycée
git config --global http.proxy 10.0.0.1:3128  #si proxy comme au lycée uniquement!

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

git clone https://github.com/CarolineDorian/l2pbm.git

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

Actuellement vous avez donc un répertoire projet du nom de l2pbm
bruno@elliott:~/Works$ tree imagepbm/
imagepbm/
└── l2pbm
    ├── l2pbm
    ├── l2pbm.c
    └── Makefile
2 directories, 3 files
bruno@elliott:~/Works$

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

fichier source c : l2pbm.c

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

/******************************************/
/** Image blanche de 800 x 600           **/
/** V1.Bogt2020 LtDorian		 **/
/**                       09/11/2020	 **/
/******************************************/
#include<stdio.h>
#include<stdlib.h>

int main()
{
       int compteur;
/* en tete de l'image */
       printf("P1\n");
/* pas de commentaire */
       printf("800 600\n");
/* génération des 480000 pixels */
       for (compteur=0;compteur<800*600; compteur++)
                       printf("0\n");
return EXIT_SUCCESS;
}
/*  faire un fichier pbm avec ce qui s'affiche */
/* ./imgblc > imgblc.pbm  */

Créons des images

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.

source : imgblc.c

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

image blanche : imgblc

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.

à 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.

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

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

Le projet sera dans un répertoire bitmap

/******************************************/
/** 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 ???

Ajoutons des axes X et Y

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

/******************************************/
/** Image blanche de 800 x 600           **/
/** V1.Bogt2025 LtDorian		 **/
/**                       29/09/2025	 **/
/******************************************/
#include<stdio.h>
#include<stdlib.h>

#define DIMX 800
#define DIMY 600

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

int main()
{
       int compteur_x; /*0 à 799 */
       int compteur_y; /*0 à 599 */

/* en tete de l'image */
       printf("P1\n");
/* 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';

       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
#Makefile petit projet avec skeletonc
CFLAGS = -g -Wall -pedantic -ansi
CC = gcc
DEB = gdb

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


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

gdb:	$(TARGET)
	$(DEB) $(TARGET)

clean:
	rm $(TARGET)

Langage C créer une image pbm